3a7bbdc..master · purescript-intl

git.iko.soy/purescript-intl

on master help sign in

src/Data/Intl/DateTimeFormat.js−2

since splitsnapshots

unifiedsplit

@@ -1,7 +1,5 @@

1"use strict";

3−exports["undefined"] = undefined;

4−

5exports.dateTimeFormatImpl = function(locales) {

3exports.dateTimeFormatImpl = function(locales) {

6 return function(options) {

4 return function(options) {

7 return new Intl.DateTimeFormat(locales, options);

5 return new Intl.DateTimeFormat(locales, options);

src/Data/Intl/DateTimeFormat.purs+94−98

@@ -1,17 +1,8 @@

1−module Data.Intl.DateTimeFormat

1+module Data.Intl.DateTimeFormat

2 ( LocalesOption

3 , LocaleMatcher(..)

4 , TimeZone(..)

5 , FormatMatcher(..)

6− , WeekdayYearMonthDayHourMinuteSecond(..)

7− , WeekdayYearMonthDay(..)

8− , YearMonthDay(..)

9− , YearMonth(..)

10− , MonthDay(..)

11− , HourMinuteSecond(..)

12− , HourMinute(..)

13− , Undefined

14− , undefined

15 , DateTimeFormatOptions(..)

6 , DateTimeFormatOptions(..)

16 , DateTimeFormatOptions'

7 , DateTimeFormatOptions'

17 , DateTimeComponents(..)

8 , DateTimeComponents(..)

@@ -31,23 +22,19 @@ import Data.Either (Either(..))

31import Data.Foreign (F, Foreign, ForeignError(..), isUndefined, readString)

22import Data.Foreign (F, Foreign, ForeignError(..), isUndefined, readString)

32import Data.Foreign.Index ((!))

23import Data.Foreign.Index ((!))

33import Data.Function.Uncurried (Fn3, Fn4, runFn3, runFn4)

24import Data.Function.Uncurried (Fn3, Fn4, runFn3, runFn4)

34−import Data.Generic.Rep (class Generic)

35−import Data.Intl.DateTimeFormat.Generic (class FormatComponent, defaultComponentRecord, formatComponent, genericFormatComponent)

25+import Data.Intl.DateTimeFormat.Class (class FormatComponent, FormatComponentRecord(FormatComponentRecord), formatComponent)

36import Data.JSDate (JSDate)

26import Data.JSDate (JSDate)

37import Data.Maybe (Maybe(..), fromMaybe, maybe)

27import Data.Maybe (Maybe(..), fromMaybe, maybe)

38−import Data.Newtype (class Newtype)

28+import Data.Newtype (class Newtype, un)

39import Data.StrMap (union)

29import Data.StrMap (union)

40import Data.Symbol (SProxy(..))

30import Data.Symbol (SProxy(..))

41import Data.Traversable (sequence)

31import Data.Traversable (sequence)

42−import Data.Variant (Variant, default, on)

32+import Data.Variant (Variant, case_, default, on)

43import Prelude (class Eq, class Show, Unit, bind, id, pure, show, (#), ($), (<$>), (<<<), (>>=))

33import Prelude (class Eq, class Show, Unit, bind, id, pure, show, (#), ($), (<$>), (<<<), (>>=))

44import Unsafe.Coerce (unsafeCoerce)

34import Unsafe.Coerce (unsafeCoerce)

46foreign import data LocalesOption' :: Type

36foreign import data LocalesOption' :: Type

48−foreign import data Undefined :: Type

49−foreign import undefined :: Undefined

50−

51foreign import dateTimeFormatImpl :: LocalesOption' -> DateTimeFormatOptions_ -> DateTimeFormat

38foreign import dateTimeFormatImpl :: LocalesOption' -> DateTimeFormatOptions_ -> DateTimeFormat

53newtype DateTimeFormatOptions_ = DateTimeFormatOptions_

40newtype DateTimeFormatOptions_ = DateTimeFormatOptions_

@@ -99,85 +86,6 @@ instance showFormatMatcher :: Show FormatMatcher where

99 show FMBasic = "basic"

86 show FMBasic = "basic"

100 show FMBestFit = "best fit"

87 show FMBestFit = "best fit"

101

102−newtype WeekdayYearMonthDayHourMinuteSecond = WeekdayYearMonthDayHourMinuteSecond

103− { weekday :: StringRep

104− , year :: NumericRep

105− , month :: MonthRep

106− , day :: NumericRep

107− , hour :: NumericRep

108− , minute :: NumericRep

109− , second :: NumericRep

110− }

111−

112−derive instance genericWeekdayYearMonthDayHourMinuteSecond :: Generic WeekdayYearMonthDayHourMinuteSecond _

113−

114−instance formatComponentWeekdayYearMonthDayHourMinuteSecond :: FormatComponent WeekdayYearMonthDayHourMinuteSecond where

115− formatComponent = genericFormatComponent

116−

117−newtype WeekdayYearMonthDay = WeekdayYearMonthDay

118− { weekday :: StringRep

119− , year :: NumericRep

120− , month :: MonthRep

121− , day :: NumericRep

122− }

123−

124−derive instance genericWeekdayYearMonthDay :: Generic WeekdayYearMonthDay _

125−

126−instance formatComponentWeekdayYearMonthDay :: FormatComponent WeekdayYearMonthDay where

127− formatComponent = genericFormatComponent

128−

129−newtype YearMonthDay = YearMonthDay

130− { year :: NumericRep

131− , month :: MonthRep

132− , day :: NumericRep

133− }

134−

135−derive instance genericYearMonthDay :: Generic YearMonthDay _

136−

137−instance formatComponentYearMonthDay :: FormatComponent YearMonthDay where

138− formatComponent = genericFormatComponent

139−

140−newtype YearMonth = YearMonth

141− { year :: NumericRep

142− , month :: MonthRep

143− }

144−

145−derive instance genericYearMonth :: Generic YearMonth _

146−

147−instance formatComponentYearMonth :: FormatComponent YearMonth where

148− formatComponent = genericFormatComponent

149−

150−newtype MonthDay = MonthDay

151− { month :: MonthRep

152− , day :: NumericRep

153− }

154−

155−derive instance genericMonthDay :: Generic MonthDay _

156−

157−instance formatComponentMonthDay :: FormatComponent MonthDay where

158− formatComponent = genericFormatComponent

159−

160−newtype HourMinuteSecond = HourMinuteSecond

161− { hour :: NumericRep

162− , minute :: NumericRep

163− , second :: NumericRep

164− }

165−

166−derive instance genericHourMinuteSecond :: Generic HourMinuteSecond _

167−

168−instance formatComponentHourMinuteSecond :: FormatComponent HourMinuteSecond where

169− formatComponent = genericFormatComponent

170−

171−newtype HourMinute = HourMinute

172− { hour :: NumericRep

173− , minute :: NumericRep

174− }

175−

176−derive instance genericHourMinute :: Generic HourMinute _

177−

178−instance formatComponentHourMinute :: FormatComponent HourMinute where

179− formatComponent = genericFormatComponent

180−

181type DateTimeComponents a =

89type DateTimeComponents a =

182 Variant

90 Variant

183 ( weekdayYearMonthDayHourMinuteSecond :: WeekdayYearMonthDayHourMinuteSecond

91 ( weekdayYearMonthDayHourMinuteSecond :: WeekdayYearMonthDayHourMinuteSecond

@@ -212,7 +120,7 @@ formatDateTimeOptions (DateTimeFormatOptions opts comps) = merge opts' (compsCoe

212 , hour12: fromMaybe (unsafeCoerce undefined) opts.hour12

120 , hour12: fromMaybe (unsafeCoerce undefined) opts.hour12

213 , formatMatcher: maybe undefinedString show opts.formatMatcher

121 , formatMatcher: maybe undefinedString show opts.formatMatcher

214 }

122 }

215− comps' = default (defaultComponentRecord)

123+ comps' = un FormatComponentRecord $ case_

216 # on (SProxy :: SProxy "weekdayYearMonthDayHourMinuteSecond") formatComponent

124 # on (SProxy :: SProxy "weekdayYearMonthDayHourMinuteSecond") formatComponent

217 # on (SProxy :: SProxy "weekdayYearMonthDay") formatComponent

125 # on (SProxy :: SProxy "weekdayYearMonthDay") formatComponent

218 # on (SProxy :: SProxy "yearMonthDay") formatComponent

126 # on (SProxy :: SProxy "yearMonthDay") formatComponent

@@ -288,6 +196,88 @@ foreign import createDateTimeFormatImpl

288 DateTimeFormatOptions_

196 DateTimeFormatOptions_

289 (F DateTimeFormat)

197 (F DateTimeFormat)

290

198

199+-- | Examples

200+-- | ``` purescript

201+-- | import Data.Variant (inj)

202+-- |

203+-- | fmtHourMinute = F DateTimeFormat

204+-- | fmtHourMinute = createDateTimeFormat locale opts

205+-- | where

206+-- | locale = inj (SProxy :: SProxy "locale") "en-GB"

207+-- | opts = (DateTimeFormatOptions

208+-- | { localeMatcher: Nothing

209+-- | , timeZone: (Just (TimeZone "Europe/London"))

210+-- | , hour12: Just false

211+-- | , formatMatcher: Nothing

212+-- | }

213+-- | (inj (SProxy :: SProxy "hourMinute")

214+-- | (HourMinute {hour: TwoDigit, minute: TwoDigit}))

215+-- |

216+-- |

217+-- | fmtDate :: F DateTimeFormat

218+-- | fmtDate = createDateTimeFormat locale opts

219+-- | wher

220+-- | locale = inj (SProxy :: SProxy "locale") "en-GB"

221+-- | opts :: DateTimeFormatOptions'

222+-- | opts =

223+-- | (DateTimeFormatOptions

224+-- | { localeMatcher: Nothing

225+-- | , timeZone: (Just (TimeZone "Europe/London"))

226+-- | , hour12: Just true

227+-- | , formatMatcher: Nothing

228+-- | }

229+-- | (inj

230+-- | (SProxy :: SProxy "weekdayYearMonthDayHourMinuteSecond")

231+-- | (WeekdayYearMonthDayHourMinuteSecond

232+-- | { weekday: Short

233+-- | , year: Numeric

234+-- | , month: MonthLong

235+-- | , day: Numeric

236+-- | , hour: Numeric

237+-- | , minute: Numeric

238+-- | , second: Numeric

239+-- | }

240+-- | )

241+-- | )

242+-- | )

243+-- | ```

244+-- | You have predifined types: `WeekdayYearMonthDayHourMinuteSecond`,

245+-- | `WeekdayYearMonthDay`, `YearMonthDay`, `YearMonth`, `MonthDay`,

246+-- | `HourMinuteSecond`, `HourMinute`. But you can also provide your own by

247+-- | implementing `FormatComponent` class (or by deriving it), e.g.

248+-- | ``` purescript

249+-- | newtype EraYear = EraYear

250+-- | { era :: StringRep

251+-- | , year :: NumericRep

252+-- | }

253+-- |

254+-- | derive instance genericEraYear :: Generic EraYear _

255+-- |

256+-- | instance formatComponentEraYear :: FormatComponent EraYear where

257+-- | formatComponent = genericFormatComponent

258+-- |

259+-- | fmtEraYear :: F DateTimeFormat

260+-- | fmtEraYear = createDateTimeFormat locales opts

261+-- | where

262+-- | locale = inj (SProxy :: SProxy "locale") "en-GB"

263+-- | opts :: DateTimeFormatOptions EraYear

264+-- | opts =

265+-- | (DateTimeFormatOptions

266+-- | { localeMatcher: Nothing

267+-- | , timeZone: (Just (TimeZone "Europe/London"))

268+-- | , hour12: Just true

269+-- | , formatMatcher: Nothing

270+-- | }

271+-- | (inj

272+-- | (SProxy :: SProxy "custom")

273+-- | (EraYear

274+-- | { era: Long

275+-- | , year: Numeric

276+-- | }

277+-- | )

278+-- | )

279+-- | )

280+-- | ```

291createDateTimeFormat

281createDateTimeFormat

292 :: forall a

282 :: forall a

293 .(FormatComponent a)

283 .(FormatComponent a)

@@ -301,6 +291,12 @@ createDateTimeFormat ls opts =

301 (toLocale ls)

291 (toLocale ls)

302 (formatDateTimeOptions opts)

292 (formatDateTimeOptions opts)

303

293

294+-- | Examples

295+-- | ``` purescript

296+-- | formatJSDate (either (const "") id $ runExcept fmtHourMinute) date -- "12:00"

297+-- | formatJSDate (either (const "") id $ fmtDate) date -- "Tue, January 2, 2018, 12:00:00 PM"

298+-- | formatJSDate (either (const "") id $ fmtEraYear) date -- "2018 Anno Domini"

299+-- | ```

304foreign import formatJSDate :: DateTimeFormat -> JSDate -> String

300foreign import formatJSDate :: DateTimeFormat -> JSDate -> String

305

301

306foreign import supportedLocalesOfImpl

302foreign import supportedLocalesOfImpl

@@ -309,7 +305,7 @@ foreign import supportedLocalesOfImpl

309 (Array String -> Either String (Array String))

305 (Array String -> Either String (Array String))

310 (Array String)

306 (Array String)

311 (Either String (Array String))

307 (Either String (Array String))

312−

308+

313foreign import formatToPartsImpl :: DateTimeFormat -> JSDate -> Array Foreign

309foreign import formatToPartsImpl :: DateTimeFormat -> JSDate -> Array Foreign

314

310

315formatToParts :: DateTimeFormat -> JSDate -> F (Array FormatParts)

311formatToParts :: DateTimeFormat -> JSDate -> F (Array FormatParts)

src/Data/Intl/DateTimeFormat/Class.pursnew file+41

@@ -0,0 +1,41 @@

1+module Data.Intl.DateTimeFormat.Class where

3+import Data.Maybe (Maybe(..))

4+import Data.Newtype (class Newtype)

5+import Prelude (class Eq, Unit)

7+newtype FormatComponentRecord = FormatComponentRecord

8+ { era :: Maybe String

9+ , weekday :: Maybe String

10+ , year :: Maybe String

11+ , month :: Maybe String

12+ , day :: Maybe String

13+ , hour :: Maybe String

14+ , minute :: Maybe String

15+ , second :: Maybe String

16+ , timeZoneName :: Maybe String

17+ }

18+

19+derive instance newtypeFormatComponentRecord :: Newtype FormatComponentRecord _

20+

21+derive instance eqFormatComponentRecord :: Eq FormatComponentRecord

22+

23+defaultComponentRecord :: FormatComponentRecord

24+defaultComponentRecord = FormatComponentRecord

25+ { era: Nothing

26+ , weekday: Nothing

27+ , year: Nothing

28+ , month: Nothing

29+ , day: Nothing

30+ , hour: Nothing

31+ , minute: Nothing

32+ , second: Nothing

33+ , timeZoneName: Nothing

34+ }

35+

36+

37+class FormatComponent a where

38+ formatComponent :: a -> FormatComponentRecord

39+

40+instance unitFormatComponent :: FormatComponent Unit where

41+ formatComponent _ = defaultComponentRecord

src/Data/Intl/DateTimeFormat/Generic.purs+5−39

@@ -1,51 +1,17 @@

1module Data.Intl.DateTimeFormat.Generic

2− ( class FormatComponent

3− , formatComponent

4− , class GenericFormatComponent

2+ ( class GenericFormatComponent

5 , genericFormatComponent'

3 , genericFormatComponent'

6 , genericFormatComponent

4 , genericFormatComponent

7 , class GenericFormatComponentFields

5 , class GenericFormatComponentFields

8 , genericFormatComponentFields

6 , genericFormatComponentFields

9− , defaultComponentRecord

10− , FormatComponentRecord

11 ) where

7 ) where

13import Data.Generic.Rep (class Generic, Constructor(Constructor), Field(..), NoConstructors, Product(..), Rec(..), from)

9import Data.Generic.Rep (class Generic, Constructor(Constructor), Field(..), NoConstructors, Product(..), Rec(..), from)

10+import Data.Intl.DateTimeFormat.Class (FormatComponentRecord(..))

14import Data.Intl.DateTimeFormat.Types (MonthRep, NumericRep, TimeZoneNameRep, StringRep)

11import Data.Intl.DateTimeFormat.Types (MonthRep, NumericRep, TimeZoneNameRep, StringRep)

15import Data.Maybe (Maybe(..))

12import Data.Maybe (Maybe(..))

16import Data.StrMap (StrMap, lookup, singleton, union)

13import Data.StrMap (StrMap, lookup, singleton, union)

17−import Prelude (Unit, show)

14+import Prelude (show)

18−

19−type FormatComponentRecord =

20− { era :: Maybe String

21− , weekday :: Maybe String

22− , year :: Maybe String

23− , month :: Maybe String

24− , day :: Maybe String

25− , hour :: Maybe String

26− , minute :: Maybe String

27− , second :: Maybe String

28− , timeZoneName :: Maybe String

29− }

30−

31−defaultComponentRecord :: FormatComponentRecord

32−defaultComponentRecord =

33− { era: Nothing

34− , weekday: Nothing

35− , year: Nothing

36− , month: Nothing

37− , day: Nothing

38− , hour: Nothing

39− , minute: Nothing

40− , second: Nothing

41− , timeZoneName: Nothing

42− }

43−

44−class FormatComponent a where

45− formatComponent :: a -> FormatComponentRecord

46−

47−instance unitFormatComponent :: FormatComponent Unit where

48− formatComponent _ = defaultComponentRecord

50class GenericFormatComponent a where

16class GenericFormatComponent a where

51 genericFormatComponent' :: a -> FormatComponentRecord

17 genericFormatComponent' :: a -> FormatComponentRecord

@@ -54,7 +20,7 @@ class GenericFormatComponentFields a where

54 genericFormatComponentFields :: a -> StrMap String

20 genericFormatComponentFields :: a -> StrMap String

56instance genericFormatComponentNoConsturctors :: GenericFormatComponent NoConstructors where

22instance genericFormatComponentNoConsturctors :: GenericFormatComponent NoConstructors where

57− genericFormatComponent' a =

23+ genericFormatComponent' a = FormatComponentRecord

58 { era: Nothing

24 { era: Nothing

59 , weekday: Nothing

25 , weekday: Nothing

60 , year: Nothing

26 , year: Nothing

@@ -114,7 +80,7 @@ instance genericFormatComponentFieldsProduct

114instance genericFormatComponentRec

80instance genericFormatComponentRec

115 :: (GenericFormatComponentFields a)

81 :: (GenericFormatComponentFields a)

116 => GenericFormatComponent (Rec a) where

82 => GenericFormatComponent (Rec a) where

117− genericFormatComponent' (Rec a) =

83+ genericFormatComponent' (Rec a) = FormatComponentRecord

118 { era: "era" `lookup` u

84 { era: "era" `lookup` u

119 , weekday: "weekday" `lookup` u

85 , weekday: "weekday" `lookup` u

120 , year: "year" `lookup` u

86 , year: "year" `lookup` u

src/Data/Intl/DateTimeFormat/Types.jsnew file+3

@@ -0,0 +1,3 @@

1+"use strict";

3+exports["undefined"] = undefined;

src/Data/Intl/DateTimeFormat/Types.purs+161−3

@@ -6,16 +6,32 @@ module Data.Intl.DateTimeFormat.Types

6 , FormatParts(..)

7 , readFormatParts

8 , ResolvedOptions(..)

9+ , WeekdayYearMonthDayHourMinuteSecond(..)

10+ , WeekdayYearMonthDay(..)

11+ , YearMonthDay(..)

12+ , YearMonth(..)

13+ , MonthDay(..)

14+ , HourMinuteSecond(..)

15+ , HourMinute(..)

16+ , Undefined

17+ , undefined

9 ) where

18 ) where

11import Data.Foreign (F, Foreign, ForeignError(..), fail, readString)

20import Data.Foreign (F, Foreign, ForeignError(..), fail, readString)

12import Data.Foreign.Index ((!))

21import Data.Foreign.Index ((!))

22+import Data.Intl.DateTimeFormat.Class (class FormatComponent, FormatComponentRecord(..), defaultComponentRecord)

13−import Data.Maybe (Maybe)

23+import Data.Maybe (Maybe(..))

14−import Data.Newtype (class Newtype)

24+import Data.Newtype (class Newtype, over)

15−import Prelude (class Show, bind, pure, ($), (<>), (>>=))

25+import Prelude (class Eq, class Show, bind, pure, show, ($), (<>), (>>=))

26+

27+foreign import data Undefined :: Type

28+

29+foreign import undefined :: Undefined

17data StringRep = Narrow | Short | Long

31data StringRep = Narrow | Short | Long

33+derive instance eqStringRep :: Eq StringRep

34+

19instance showStringRep :: Show StringRep where

35instance showStringRep :: Show StringRep where

20 show Narrow = "narrow"

36 show Narrow = "narrow"

21 show Short = "short"

37 show Short = "short"

@@ -23,12 +39,16 @@ instance showStringRep :: Show StringRep where

24data NumericRep = Numeric | TwoDigit

40data NumericRep = Numeric | TwoDigit

42+derive instance eqNumericRep :: Eq NumericRep

43+

26instance showNumericRep :: Show NumericRep where

44instance showNumericRep :: Show NumericRep where

27 show Numeric = "numeric"

45 show Numeric = "numeric"

28 show TwoDigit = "2-digit"

46 show TwoDigit = "2-digit"

30data MonthRep = MonthNumeric | MonthTwoDigit | MonthNarrow | MonthShort | MonthLong

48data MonthRep = MonthNumeric | MonthTwoDigit | MonthNarrow | MonthShort | MonthLong

50+derive instance eqMonthRep :: Eq MonthRep

51+

32instance showMonthRep :: Show MonthRep where

52instance showMonthRep :: Show MonthRep where

33 show MonthNumeric = "numeric"

53 show MonthNumeric = "numeric"

34 show MonthTwoDigit = "2-digit"

54 show MonthTwoDigit = "2-digit"

@@ -38,6 +58,8 @@ instance showMonthRep :: Show MonthRep where

39data TimeZoneNameRep = TimeZoneNameShort | TimeZoneNameLong

59data TimeZoneNameRep = TimeZoneNameShort | TimeZoneNameLong

61+derive instance eqTimeZoneNameRep :: Eq TimeZoneNameRep

62+

41instance showTimeZoneRep :: Show TimeZoneNameRep where

63instance showTimeZoneRep :: Show TimeZoneNameRep where

42 show TimeZoneNameShort = "short"

64 show TimeZoneNameShort = "short"

43 show TimeZoneNameLong = "long"

65 show TimeZoneNameLong = "long"

@@ -53,6 +75,8 @@ data FormatParts

53 | DayPeriod String

75 | DayPeriod String

54 | Literal String

76 | Literal String

78+derive instance eqFormatParts :: Eq FormatParts

79+

56readFormatParts :: Foreign -> F FormatParts

80readFormatParts :: Foreign -> F FormatParts

57readFormatParts val = do

81readFormatParts val = do

58 type_ <- val ! "type" >>= readString

82 type_ <- val ! "type" >>= readString

@@ -86,3 +110,137 @@ newtype ResolvedOptions = ResolvedOptions

86 }

110 }

111

88derive instance newtypeResolvedOptions :: Newtype ResolvedOptions _

112derive instance newtypeResolvedOptions :: Newtype ResolvedOptions _

113+

114+derive instance eqResolvedOptions :: Eq ResolvedOptions

115+

116+newtype WeekdayYearMonthDayHourMinuteSecond = WeekdayYearMonthDayHourMinuteSecond

117+ { weekday :: StringRep

118+ , year :: NumericRep

119+ , month :: MonthRep

120+ , day :: NumericRep

121+ , hour :: NumericRep

122+ , minute :: NumericRep

123+ , second :: NumericRep

124+ }

125+

126+derive instance newtypeWeekdayYearMonthDayHourMinuteSecond :: Newtype WeekdayYearMonthDayHourMinuteSecond _

127+

128+derive instance eqWeekdayYearMonthDayHourMinuteSecond :: Eq WeekdayYearMonthDayHourMinuteSecond

129+

130+instance formatComponentWeekdayYearMonthDayHourMinuteSecond :: FormatComponent WeekdayYearMonthDayHourMinuteSecond where

131+ formatComponent (WeekdayYearMonthDayHourMinuteSecond { weekday, year, month, day, hour, minute, second }) = over FormatComponentRecord

132+ (\r -> r { weekday = Just (show weekday)

133+ , year = Just (show year)

134+ , month = Just (show month)

135+ , day = Just (show day)

136+ , hour = Just (show hour)

137+ , minute = Just (show minute)

138+ , second = Just (show second)

139+ }

140+ ) defaultComponentRecord

141+

142+newtype WeekdayYearMonthDay = WeekdayYearMonthDay

143+ { weekday :: StringRep

144+ , year :: NumericRep

145+ , month :: MonthRep

146+ , day :: NumericRep

147+ }

148+

149+derive instance newtypeWeekdayYearMonthDay :: Newtype WeekdayYearMonthDay _

150+

151+derive instance eqWeekdayYearMonthDay :: Eq WeekdayYearMonthDay

152+

153+instance formatComponentWeekdayYearMonthDay :: FormatComponent WeekdayYearMonthDay where

154+ formatComponent (WeekdayYearMonthDay { weekday, year, month, day }) = over FormatComponentRecord

155+ (\r -> r { weekday = Just (show weekday)

156+ , year = Just (show year)

157+ , month = Just (show month)

158+ , day = Just (show day)

159+ }

160+ ) defaultComponentRecord

161+

162+

163+newtype YearMonthDay = YearMonthDay

164+ { year :: NumericRep

165+ , month :: MonthRep

166+ , day :: NumericRep

167+ }

168+

169+derive instance newtypeYearMonthDay :: Newtype YearMonthDay _

170+

171+derive instance eqYearMonthDay :: Eq YearMonthDay

172+

173+instance formatComponentYearMonthDay :: FormatComponent YearMonthDay where

174+ formatComponent (YearMonthDay { year, month, day }) = over FormatComponentRecord

175+ (\r -> r { year = Just (show year)

176+ , month = Just (show month)

177+ , day = Just (show day)

178+ }

179+ ) defaultComponentRecord

180+

181+

182+newtype YearMonth = YearMonth

183+ { year :: NumericRep

184+ , month :: MonthRep

185+ }

186+

187+derive instance newtypeYearMonth :: Newtype YearMonth _

188+

189+derive instance eqYearMonth :: Eq YearMonth

190+

191+instance formatComponentYearMonth :: FormatComponent YearMonth where

192+ formatComponent (YearMonth { year, month }) = over FormatComponentRecord

193+ (\r -> r { year = Just (show year)

194+ , month = Just (show month)

195+ }

196+ ) defaultComponentRecord

197+

198+newtype MonthDay = MonthDay

199+ { month :: MonthRep

200+ , day :: NumericRep

201+ }

202+

203+derive instance newtypeMonthDay :: Newtype MonthDay _

204+

205+derive instance eqMonthDay :: Eq MonthDay

206+

207+instance formatComponentMonthDay :: FormatComponent MonthDay where

208+ formatComponent (MonthDay { month, day }) = over FormatComponentRecord

209+ (\r -> r { month = Just (show month)

210+ , day = Just (show day)

211+ }

212+ ) defaultComponentRecord

213+

214+newtype HourMinuteSecond = HourMinuteSecond

215+ { hour :: NumericRep

216+ , minute :: NumericRep

217+ , second :: NumericRep

218+ }

219+

220+derive instance newtypeHourMinuteSecond :: Newtype HourMinuteSecond _

221+

222+derive instance eqHourMinuteSecond :: Eq HourMinuteSecond

223+

224+instance formatComponentHourMinuteSecond :: FormatComponent HourMinuteSecond where

225+ formatComponent (HourMinuteSecond { hour, minute, second }) = over FormatComponentRecord

226+ (\r -> r { hour = Just (show hour)

227+ , minute = Just (show minute)

228+ , second = Just (show second)

229+ }

230+ ) defaultComponentRecord

231+

232+newtype HourMinute = HourMinute

233+ { hour :: NumericRep

234+ , minute :: NumericRep

235+ }

236+

237+derive instance newtypeHourMinute :: Newtype HourMinute _

238+

239+derive instance eqHourMinute :: Eq HourMinute

240+

241+instance formatComponentHourMinute :: FormatComponent HourMinute where

242+ formatComponent (HourMinute { hour, minute }) = over FormatComponentRecord

243+ (\r -> r { hour = Just (show hour)

244+ , minute = Just (show minute)

245+ }

246+ ) defaultComponentRecord

test/Test/Main.purs+3−2

@@ -12,7 +12,8 @@ import Data.Foldable (intercalate)

12import Data.Foreign (F, renderForeignError)

13import Data.Generic.Rep (class Generic)

14import Data.Intl.DateTimeFormat (DateTimeFormatOptions(DateTimeFormatOptions), DateTimeFormatOptions', HourMinute(HourMinute), HourMinuteSecond(HourMinuteSecond), LocalesOption, MonthDay(MonthDay), MonthRep(MonthTwoDigit, MonthNumeric, MonthNarrow, MonthShort, MonthLong), NumericRep(Numeric, TwoDigit), ResolvedOptions(..), StringRep(Short, Long), TimeZone(TimeZone), WeekdayYearMonthDay(WeekdayYearMonthDay), WeekdayYearMonthDayHourMinuteSecond(WeekdayYearMonthDayHourMinuteSecond), YearMonth(YearMonth), YearMonthDay(YearMonthDay), createDateTimeFormat, formatJSDate, resolvedOptions, supportedLocalesOf)

15−import Data.Intl.DateTimeFormat.Generic (class FormatComponent, genericFormatComponent)

15+import Data.Intl.DateTimeFormat.Class (class FormatComponent, FormatComponentRecord(..))

16+import Data.Intl.DateTimeFormat.Generic (genericFormatComponent)

16import Data.JSDate (JSDate, fromDateTime)

17import Data.JSDate (JSDate, fromDateTime)

17import Data.Maybe (Maybe(..), isJust, isNothing)

18import Data.Maybe (Maybe(..), isJust, isNothing)

18import Data.Symbol (SProxy(..))

19import Data.Symbol (SProxy(..))

@@ -36,7 +37,7 @@ instance formatComponentEraYear :: FormatComponent EraYear where

36newtype Era = Era StringRep

37newtype Era = Era StringRep

38instance formatComponentEra :: FormatComponent Era where

39instance formatComponentEra :: FormatComponent Era where

39− formatComponent (Era r) =

40+ formatComponent (Era r) = FormatComponentRecord

40 { era: Just (show r)

41 { era: Just (show r)

41 , weekday: Nothing

42 , weekday: Nothing

42 , year: Nothing

43 , year: Nothing