2df977c...master · purescript-intl

git.iko.soy/purescript-intl

on master help sign in

.travis.yml−3

since splitsnapshots

unifiedsplit

@@ -4,9 +4,6 @@ sudo: required

4node_js: stable

5env:

6 - PATH=$HOME/purescript:$PATH

7−cache:

8− - directories:

9− - $HOME/purescript

10install:

7install:

11 - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p')

8 - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p')

12 - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz

9 - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz

bower.json+1−1

@@ -9,7 +9,7 @@

9 "license": "MPL-2.0",

10 "repository": {

11 "type": "git",

12− "url": "git://github.com/purescript/purescript-prelude.git"

12+ "url": "git://github.com/coot/purescript-intl.git"

13 },

14 "dependencies": {

15 "purescript-prelude": "^3.0.0",

src/Data/Intl/DateTimeFormat.js+6−6

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

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);

8 };

6 };

9};

7};

11−exports.createDateTimeFormatterImpl = function(locales) {

9+exports.createDateTimeFormatImpl = function(throwError, pure, locales, opts) {

12− return function(opts) {

10+ try {

13− return Intl.DateTimeFormat(locales, opts);

11+ return pure(Intl.DateTimeFormat(locales, opts));

14− };

12+ } catch (e) {

13+ return throwError(e.message);

14+ }

15};

17exports.formatJSDate = function(formatter) {

src/Data/Intl/DateTimeFormat.purs+131−122

@@ -1,22 +1,13 @@

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(..)

18− , DateTimeFormatter

9+ , DateTimeFormat

19− , createDateTimeFormatter

10+ , createDateTimeFormat

20 , formatJSDate

11 , formatJSDate

21 , module Data.Intl.DateTimeFormat.Types

12 , module Data.Intl.DateTimeFormat.Types

22 , supportedLocalesOf

13 , supportedLocalesOf

@@ -26,27 +17,23 @@ module Data.Intl.DateTimeFormat

27import Data.Intl.DateTimeFormat.Types

18import Data.Intl.DateTimeFormat.Types

20+import Control.Monad.Error.Class (throwError)

29import Data.Either (Either(..))

21import Data.Either (Either(..))

30−import Data.Foreign (F, Foreign, isUndefined, readString)

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

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

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

32−import Data.Function.Uncurried (Fn3, runFn3)

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

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

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

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

35import Data.JSDate (JSDate)

26import Data.JSDate (JSDate)

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

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

37−import Data.Newtype (class Newtype)

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

38import Data.StrMap (union)

29import Data.StrMap (union)

39import Data.Symbol (SProxy(..))

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

40import Data.Traversable (sequence)

31import Data.Traversable (sequence)

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

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

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

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

43import Unsafe.Coerce (unsafeCoerce)

34import Unsafe.Coerce (unsafeCoerce)

45foreign import data LocalesOption' :: Type

36foreign import data LocalesOption' :: Type

46−foreign import data DateTimeFormat :: Type

47−

48−foreign import data Undefined :: Type

49−foreign import undefined :: Undefined

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

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

@@ -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

@@ -278,36 +186,137 @@ formatDateTimeOptions (DateTimeFormatOptions opts comps) = merge opts' (compsCoe

278 -> DateTimeFormatOptions_

186 -> DateTimeFormatOptions_

279 merge a b = unsafeCoerce $ union (unsafeCoerce a) (unsafeCoerce b)

187 merge a b = unsafeCoerce $ union (unsafeCoerce a) (unsafeCoerce b)

280

188

281−foreign import data DateTimeFormatter :: Type

189+foreign import data DateTimeFormat :: Type

282−

283−foreign import createDateTimeFormatterImpl

284− :: LocalesOption'

285− -> DateTimeFormatOptions_

286− -> DateTimeFormatter

287

190

288−createDateTimeFormatter

191+foreign import createDateTimeFormatImpl

192+ :: Fn4

193+ (forall a. String -> F a)

194+ (forall a. a -> F a)

195+ LocalesOption'

196+ DateTimeFormatOptions_

197+ (F DateTimeFormat)

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+-- | ```

281+createDateTimeFormat

289 :: forall a

282 :: forall a

290 .(FormatComponent a)

283 .(FormatComponent a)

291 => LocalesOption

284 => LocalesOption

292 -> DateTimeFormatOptions a

285 -> DateTimeFormatOptions a

293− -> DateTimeFormatter

286+ -> F DateTimeFormat

287+createDateTimeFormat ls opts =

288+ runFn4 createDateTimeFormatImpl

289+ (throwError <<< pure <<< ForeignError)

290+ pure

291+ (toLocale ls)

294−createDateTimeFormatter ls opts = createDateTimeFormatterImpl (toLocale ls) (formatDateTimeOptions opts)

292+ (formatDateTimeOptions opts)

295−

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+-- | ```

296−foreign import formatJSDate :: DateTimeFormatter -> JSDate -> String

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

297−

301+

298−foreign import supportedLocalesOfImpl :: Fn3 (String -> Either String (Array String)) (Array String -> Either String (Array String)) (Array String) (Either String (Array String))

302+foreign import supportedLocalesOfImpl

299−

303+ :: Fn3

304+ (String -> Either String (Array String))

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

306+ (Array String)

307+ (Either String (Array String))

308+

300−foreign import formatToPartsImpl :: DateTimeFormatter -> JSDate -> Array Foreign

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

301−

310+

302−formatToParts :: DateTimeFormatter -> JSDate -> F (Array FormatParts)

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

303formatToParts formatter date = sequence $ readFormatParts <$> formatToPartsImpl formatter date

312formatToParts formatter date = sequence $ readFormatParts <$> formatToPartsImpl formatter date

304

313

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

314supportedLocalesOf :: Array String -> Either String (Array String)

306supportedLocalesOf locales = runFn3 supportedLocalesOfImpl Left Right locales

315supportedLocalesOf locales = runFn3 supportedLocalesOfImpl Left Right locales

307

316

308−foreign import resolvedOptionsImpl :: DateTimeFormatter -> Foreign

317+foreign import resolvedOptionsImpl :: DateTimeFormat -> Foreign

309

318

310−resolvedOptions :: DateTimeFormatter -> F ResolvedOptions

319+resolvedOptions :: DateTimeFormat -> F ResolvedOptions

311resolvedOptions fmt = do

320resolvedOptions fmt = do

312 locale <- obj ! "locale" >>= readString

321 locale <- obj ! "locale" >>= readString

313 calendar <- obj ! "calendar" >>= readString

322 calendar <- obj ! "calendar" >>= readString

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+45−24

@@ -6,19 +6,20 @@ import Control.Monad.Eff (Eff)

6import Control.Monad.Eff.Console (CONSOLE)

7import Control.Monad.Except (runExcept)

8import Data.DateTime (Date, DateTime(..), Month(..), canonicalDate)

9−import Data.Either (Either(..), isLeft)

9+import Data.Either (Either(..), fromRight, isLeft)

10import Data.Enum (toEnum)

11import Data.Foldable (intercalate)

12−import Data.Foreign (renderForeignError)

12+import Data.Foreign (F, renderForeignError)

13import Data.Generic.Rep (class Generic)

14−import 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), createDateTimeFormatter, formatJSDate, resolvedOptions, supportedLocalesOf)

14+import 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(..))

19import Data.Time (Time(..))

20import Data.Time (Time(..))

20import Data.Variant (inj)

21import Data.Variant (inj)

21−import Partial.Unsafe (unsafeCrashWith)

22+import Partial.Unsafe (unsafeCrashWith, unsafePartial)

22import Test.Assert (ASSERT, assert')

23import Test.Assert (ASSERT, assert')

24type Tests = Eff (console :: CONSOLE, assert :: ASSERT) Unit

25type Tests = Eff (console :: CONSOLE, assert :: ASSERT) Unit

@@ -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

@@ -52,11 +53,14 @@ main :: Tests

52main = do

53main = do

53 let

54 let

56+ unsafeFromF :: forall a. F a -> a

57+ unsafeFromF = unsafePartial fromRight <<< runExcept

58+

55 locales :: LocalesOption

59 locales :: LocalesOption

56 locales = inj (SProxy :: SProxy "locale") "en-US"

60 locales = inj (SProxy :: SProxy "locale") "en-US"

58− fmtHourMinute =

62+ fmtError =

59− createDateTimeFormatter locales opts

63+ createDateTimeFormat (inj (SProxy :: SProxy "locale") "") opts

60 where

64 where

61 opts :: DateTimeFormatOptions'

65 opts :: DateTimeFormatOptions'

62 opts =

66 opts =

@@ -69,8 +73,22 @@ main = do

69 (inj (SProxy :: SProxy "hourMinute") (HourMinute {hour: TwoDigit, minute: TwoDigit}))

73 (inj (SProxy :: SProxy "hourMinute") (HourMinute {hour: TwoDigit, minute: TwoDigit}))

70 )

74 )

76+ fmtHourMinute = unsafeFromF $

77+ createDateTimeFormat locales opts

78+ where

79+ opts :: DateTimeFormatOptions'

80+ opts =

81+ (DateTimeFormatOptions

82+ { localeMatcher: Nothing

83+ , timeZone: (Just (TimeZone "Europe/London"))

84+ , hour12: Just false

85+ , formatMatcher: Nothing

86+ }

87+ (inj (SProxy :: SProxy "hourMinute") (HourMinute {hour: TwoDigit, minute: TwoDigit}))

88+ )

89+

72− fmtHourMinuteSecond =

90+ fmtHourMinuteSecond = unsafeFromF $

73− createDateTimeFormatter locales opts

91+ createDateTimeFormat locales opts

74 where

92 where

75 opts :: DateTimeFormatOptions'

93 opts :: DateTimeFormatOptions'

76 opts =

94 opts =

@@ -83,8 +101,8 @@ main = do

83 (inj (SProxy :: SProxy "hourMinuteSecond") (HourMinuteSecond {hour: Numeric, minute: Numeric, second: Numeric}))

101 (inj (SProxy :: SProxy "hourMinuteSecond") (HourMinuteSecond {hour: Numeric, minute: Numeric, second: Numeric}))

84 )

102 )

103

86− fmtWeekdayYearMonthDayHourMinuteSecond =

104+ fmtWeekdayYearMonthDayHourMinuteSecond = unsafeFromF $

87− createDateTimeFormatter locales opts

105+ createDateTimeFormat locales opts

88 where

106 where

89 opts :: DateTimeFormatOptions'

107 opts :: DateTimeFormatOptions'

90 opts =

108 opts =

@@ -109,8 +127,8 @@ main = do

109 )

127 )

110 )

128 )

111

129

112− fmtWeekdayYearMonthDay =

130+ fmtWeekdayYearMonthDay = unsafeFromF $

113− createDateTimeFormatter locales opts

131+ createDateTimeFormat locales opts

114 where

132 where

115 opts :: DateTimeFormatOptions'

133 opts :: DateTimeFormatOptions'

116 opts =

134 opts =

@@ -132,8 +150,8 @@ main = do

132 )

150 )

133 )

151 )

134

152

135− fmtYearMonthDay =

153+ fmtYearMonthDay = unsafeFromF $

136− createDateTimeFormatter locales opts

154+ createDateTimeFormat locales opts

137 where

155 where

138 opts :: DateTimeFormatOptions'

156 opts :: DateTimeFormatOptions'

139 opts =

157 opts =

@@ -154,8 +172,8 @@ main = do

154 )

172 )

155 )

173 )

156

174

157− fmtYearMonth =

175+ fmtYearMonth = unsafeFromF $

158− createDateTimeFormatter locales opts

176+ createDateTimeFormat locales opts

159 where

177 where

160 opts :: DateTimeFormatOptions'

178 opts :: DateTimeFormatOptions'

161 opts =

179 opts =

@@ -175,8 +193,8 @@ main = do

175 )

193 )

176 )

194 )

177

195

178− fmtMonthDay =

196+ fmtMonthDay = unsafeFromF $

179− createDateTimeFormatter locales opts

197+ createDateTimeFormat locales opts

180 where

198 where

181 opts :: DateTimeFormatOptions'

199 opts :: DateTimeFormatOptions'

182 opts =

200 opts =

@@ -196,8 +214,8 @@ main = do

196 )

214 )

197 )

215 )

198

216

199− fmtEraYear =

217+ fmtEraYear = unsafeFromF $

200− createDateTimeFormatter locales opts

218+ createDateTimeFormat locales opts

201 where

219 where

202 opts :: DateTimeFormatOptions EraYear

220 opts :: DateTimeFormatOptions EraYear

203 opts =

221 opts =

@@ -217,8 +235,8 @@ main = do

217 )

235 )

218 )

236 )

219

237

220− fmtEra =

238+ fmtEra = unsafeFromF $

221− createDateTimeFormatter locales opts

239+ createDateTimeFormat locales opts

222 where

240 where

223 opts :: DateTimeFormatOptions Era

241 opts :: DateTimeFormatOptions Era

224 opts =

242 opts =

@@ -262,6 +280,9 @@ main = do

262 case jsDate of

280 case jsDate of

263 Nothing -> unsafeCrashWith "jsDate not parsed"

281 Nothing -> unsafeCrashWith "jsDate not parsed"

264 Just d -> do

282 Just d -> do

283+

284+ assert' "fmtError expected to return error" $ isLeft (runExcept fmtError)

285+

265 let fmtDate1 = formatJSDate fmtWeekdayYearMonthDayHourMinuteSecond d

286 let fmtDate1 = formatJSDate fmtWeekdayYearMonthDayHourMinuteSecond d

266 fmtDate1Expected = "Tue, January 2, 2018, 12:00:00 PM"

287 fmtDate1Expected = "Tue, January 2, 2018, 12:00:00 PM"

267 assert' ("fmtWeekdayYearMonthDayHourMinuteSecond: got: '" <> fmtDate1 <> "' expected: '" <> fmtDate1Expected <> "'")

288 assert' ("fmtWeekdayYearMonthDayHourMinuteSecond: got: '" <> fmtDate1 <> "' expected: '" <> fmtDate1Expected <> "'")