@formatjs/ecma402-abstract 1.0.3 → 1.2.2

package/lib/src/DateTimeFormat/BestFitFormatMatcher.js

@@ -0,0 +1,119 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { invariant } from '../utils';
+import { DATE_TIME_PROPS, removalPenalty, additionPenalty, differentNumericTypePenalty, longMorePenalty, shortMorePenalty, shortLessPenalty, longLessPenalty, } from './utils';
+import { parseDateTimeSkeleton } from './skeleton';
+function isNumericType(t) {
+    return t === 'numeric' || t === '2-digit';
+}
+/**
+ * Credit: https://github.com/andyearnshaw/Intl.js/blob/0958dc1ad8153f1056653ea22b8208f0df289a4e/src/12.datetimeformat.js#L611
+ * with some modifications
+ * @param options
+ * @param format
+ */
+export function bestFitFormatMatcherScore(options, format) {
+    var score = 0;
+    if (options.hour12 && !format.hour12) {
+        score -= removalPenalty;
+    }
+    else if (!options.hour12 && format.hour12) {
+        score -= additionPenalty;
+    }
+    for (var _i = 0, DATE_TIME_PROPS_1 = DATE_TIME_PROPS; _i < DATE_TIME_PROPS_1.length; _i++) {
+        var prop = DATE_TIME_PROPS_1[_i];
+        var optionsProp = options[prop];
+        var formatProp = format[prop];
+        if (optionsProp === undefined && formatProp !== undefined) {
+            score -= additionPenalty;
+        }
+        else if (optionsProp !== undefined && formatProp === undefined) {
+            score -= removalPenalty;
+        }
+        else if (optionsProp !== formatProp) {
+            // extra penalty for numeric vs non-numeric
+            if (isNumericType(optionsProp) !==
+                isNumericType(formatProp)) {
+                score -= differentNumericTypePenalty;
+            }
+            else {
+                var values = ['2-digit', 'numeric', 'narrow', 'short', 'long'];
+                var optionsPropIndex = values.indexOf(optionsProp);
+                var formatPropIndex = values.indexOf(formatProp);
+                var delta = Math.max(-2, Math.min(formatPropIndex - optionsPropIndex, 2));
+                if (delta === 2) {
+                    score -= longMorePenalty;
+                }
+                else if (delta === 1) {
+                    score -= shortMorePenalty;
+                }
+                else if (delta === -1) {
+                    score -= shortLessPenalty;
+                }
+                else if (delta === -2) {
+                    score -= longLessPenalty;
+                }
+            }
+        }
+    }
+    return score;
+}
+/**
+ * https://tc39.es/ecma402/#sec-bestfitformatmatcher
+ * Just alias to basic for now
+ * @param options
+ * @param formats
+ * @param implDetails Implementation details
+ */
+export function BestFitFormatMatcher(options, formats) {
+    var bestScore = -Infinity;
+    var bestFormat = formats[0];
+    invariant(Array.isArray(formats), 'formats should be a list of things');
+    for (var _i = 0, formats_1 = formats; _i < formats_1.length; _i++) {
+        var format = formats_1[_i];
+        var score = bestFitFormatMatcherScore(options, format);
+        if (score > bestScore) {
+            bestScore = score;
+            bestFormat = format;
+        }
+    }
+    var skeletonFormat = __assign({}, bestFormat);
+    var patternFormat = parseDateTimeSkeleton(bestFormat.rawPattern);
+    // Kinda following https://github.com/unicode-org/icu/blob/dd50e38f459d84e9bf1b0c618be8483d318458ad/icu4j/main/classes/core/src/com/ibm/icu/text/DateTimePatternGenerator.java
+    // Method adjustFieldTypes
+    for (var prop in patternFormat) {
+        var skeletonValue = skeletonFormat[prop];
+        var patternValue = patternFormat[prop];
+        var requestedValue = options[prop];
+        // Don't mess with minute/second or we can get in the situation of
+        // 7:0:0 which is weird
+        if (prop === 'minute' || prop === 'second') {
+            continue;
+        }
+        // Nothing to do here
+        if (!requestedValue) {
+            continue;
+        }
+        // https://unicode.org/reports/tr35/tr35-dates.html#Matching_Skeletons
+        // Looks like we should not convert numeric to alphabetic but the other way
+        // around is ok
+        if (isNumericType(patternValue) &&
+            !isNumericType(requestedValue)) {
+            continue;
+        }
+        if (skeletonValue === requestedValue) {
+            continue;
+        }
+        patternFormat[prop] = requestedValue;
+    }
+    return patternFormat;
+}

package/lib/src/DateTimeFormat/DateTimeStyleFormat.d.ts

@@ -0,0 +1,3 @@
+import { DateTimeFormatOptions, DateTimeFormatLocaleInternalData, Formats } from '../../types/date-time';
+export declare function DateTimeStyleFormat(dateStyle: DateTimeFormatOptions['dateStyle'], timeStyle: DateTimeFormatOptions['timeStyle'], dataLocaleData: DateTimeFormatLocaleInternalData): Formats;
+//# sourceMappingURL=DateTimeStyleFormat.d.ts.map

package/lib/src/DateTimeFormat/DateTimeStyleFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DateTimeStyleFormat.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/DateTimeStyleFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,gCAAgC,EAChC,OAAO,EACR,MAAM,uBAAuB,CAAC;AAG/B,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,qBAAqB,CAAC,WAAW,CAAC,EAC7C,SAAS,EAAE,qBAAqB,CAAC,WAAW,CAAC,EAC7C,cAAc,EAAE,gCAAgC,GAC/C,OAAO,CAuDT"}

package/lib/src/DateTimeFormat/DateTimeStyleFormat.js

@@ -0,0 +1,50 @@
+import { invariant } from '../utils';
+export function DateTimeStyleFormat(dateStyle, timeStyle, dataLocaleData) {
+    var dateFormat, timeFormat;
+    if (timeStyle !== undefined) {
+        invariant(timeStyle === 'full' ||
+            timeStyle === 'long' ||
+            timeStyle === 'medium' ||
+            timeStyle === 'short', 'invalid timeStyle');
+        timeFormat = dataLocaleData.timeFormat[timeStyle];
+    }
+    if (dateStyle !== undefined) {
+        invariant(dateStyle === 'full' ||
+            dateStyle === 'long' ||
+            dateStyle === 'medium' ||
+            dateStyle === 'short', 'invalid dateStyle');
+        dateFormat = dataLocaleData.dateFormat[dateStyle];
+    }
+    if (dateStyle !== undefined && timeStyle !== undefined) {
+        var format = {};
+        for (var field in dateFormat) {
+            if (field !== 'pattern') {
+                // @ts-ignore
+                format[field] = dateFormat[field];
+            }
+        }
+        for (var field in timeFormat) {
+            if (field !== 'pattern' && field !== 'pattern12') {
+                // @ts-ignore
+                format[field] = timeFormat[field];
+            }
+        }
+        var connector = dataLocaleData.dateTimeFormat[dateStyle];
+        var pattern = connector
+            .replace('{0}', timeFormat.pattern)
+            .replace('{1}', dateFormat.pattern);
+        format.pattern = pattern;
+        if ('pattern12' in timeFormat) {
+            var pattern12 = connector
+                .replace('{0}', timeFormat.pattern12)
+                .replace('{1}', dateFormat.pattern);
+            format.pattern12 = pattern12;
+        }
+        return format;
+    }
+    if (timeStyle !== undefined) {
+        return timeFormat;
+    }
+    invariant(dateStyle !== undefined, 'dateStyle should not be undefined');
+    return dateFormat;
+}

package/lib/src/DateTimeFormat/FormatDateTime.d.ts

@@ -0,0 +1,8 @@
+import { PartitionDateTimePattern } from './PartitionDateTimePattern';
+/**
+ * https://tc39.es/ecma402/#sec-formatdatetime
+ * @param dtf DateTimeFormat
+ * @param x
+ */
+export declare function FormatDateTime(dtf: Intl.DateTimeFormat, x: number, implDetails: Parameters<typeof PartitionDateTimePattern>[2]): string;
+//# sourceMappingURL=FormatDateTime.d.ts.map

package/lib/src/DateTimeFormat/FormatDateTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatDateTime.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/FormatDateTime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,wBAAwB,EAAC,MAAM,4BAA4B,CAAC;AAEpE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,CAAC,EAAE,MAAM,EACT,WAAW,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,UAQ5D"}

package/lib/src/DateTimeFormat/FormatDateTime.js

@@ -0,0 +1,15 @@
+import { PartitionDateTimePattern } from './PartitionDateTimePattern';
+/**
+ * https://tc39.es/ecma402/#sec-formatdatetime
+ * @param dtf DateTimeFormat
+ * @param x
+ */
+export function FormatDateTime(dtf, x, implDetails) {
+    var parts = PartitionDateTimePattern(dtf, x, implDetails);
+    var result = '';
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        result += part.value;
+    }
+    return result;
+}

package/lib/src/DateTimeFormat/FormatDateTimeToParts.d.ts

@@ -0,0 +1,10 @@
+import { PartitionDateTimePattern } from './PartitionDateTimePattern';
+/**
+ * https://tc39.es/ecma402/#sec-formatdatetimetoparts
+ *
+ * @param dtf
+ * @param x
+ * @param implDetails
+ */
+export declare function FormatDateTimeToParts(dtf: Intl.DateTimeFormat, x: number, implDetails: Parameters<typeof PartitionDateTimePattern>[2]): Intl.DateTimeFormatPart[];
+//# sourceMappingURL=FormatDateTimeToParts.d.ts.map

package/lib/src/DateTimeFormat/FormatDateTimeToParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatDateTimeToParts.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/FormatDateTimeToParts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,wBAAwB,EAAC,MAAM,4BAA4B,CAAC;AAGpE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,CAAC,EAAE,MAAM,EACT,WAAW,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,GAC1D,IAAI,CAAC,kBAAkB,EAAE,CAU3B"}

package/lib/src/DateTimeFormat/FormatDateTimeToParts.js

@@ -0,0 +1,21 @@
+import { PartitionDateTimePattern } from './PartitionDateTimePattern';
+import { ArrayCreate } from '../../262';
+/**
+ * https://tc39.es/ecma402/#sec-formatdatetimetoparts
+ *
+ * @param dtf
+ * @param x
+ * @param implDetails
+ */
+export function FormatDateTimeToParts(dtf, x, implDetails) {
+    var parts = PartitionDateTimePattern(dtf, x, implDetails);
+    var result = ArrayCreate(0);
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        result.push({
+            type: part.type,
+            value: part.value,
+        });
+    }
+    return result;
+}

package/lib/src/DateTimeFormat/InitializeDateTimeFormat.d.ts

@@ -0,0 +1,18 @@
+import { DateTimeFormatOptions, IntlDateTimeFormatInternal, DateTimeFormatLocaleInternalData } from '../../types/date-time';
+/**
+ * https://tc39.es/ecma402/#sec-initializedatetimeformat
+ * @param dtf DateTimeFormat
+ * @param locales locales
+ * @param opts options
+ */
+export declare function InitializeDateTimeFormat(dtf: Intl.DateTimeFormat, locales: string | string[] | undefined, opts: DateTimeFormatOptions | undefined, { getInternalSlots, availableLocales, localeData, getDefaultLocale, getDefaultTimeZone, relevantExtensionKeys, tzData, uppercaseLinks, }: {
+    getInternalSlots(dtf: Intl.DateTimeFormat): IntlDateTimeFormatInternal;
+    availableLocales: string[];
+    getDefaultLocale(): string;
+    getDefaultTimeZone(): string;
+    relevantExtensionKeys: string[];
+    localeData: Record<string, DateTimeFormatLocaleInternalData>;
+    tzData: Record<string, unknown>;
+    uppercaseLinks: Record<string, string>;
+}): Intl.DateTimeFormat;
+//# sourceMappingURL=InitializeDateTimeFormat.d.ts.map

package/lib/src/DateTimeFormat/InitializeDateTimeFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializeDateTimeFormat.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/InitializeDateTimeFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EAErB,0BAA0B,EAC1B,gCAAgC,EACjC,MAAM,uBAAuB,CAAC;AAgC/B;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EACtC,IAAI,EAAE,qBAAqB,GAAG,SAAS,EACvC,EACE,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,MAAM,EACN,cAAc,GACf,EAAE;IACD,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,GAAG,0BAA0B,CAAC;IACvE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,IAAI,MAAM,CAAC;IAC3B,kBAAkB,IAAI,MAAM,CAAC;IAC7B,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gCAAgC,CAAC,CAAC;IAC7D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC,GACA,IAAI,CAAC,cAAc,CAqOrB"}

package/lib/src/DateTimeFormat/InitializeDateTimeFormat.js

@@ -0,0 +1,163 @@
+import { CanonicalizeLocaleList } from '../CanonicalizeLocaleList';
+import { ToDateTimeOptions } from './ToDateTimeOptions';
+import { GetOption } from '../GetOption';
+import { ResolveLocale } from '../ResolveLocale';
+import { IsValidTimeZoneName } from '../IsValidTimeZoneName';
+import { CanonicalizeTimeZoneName } from '../CanonicalizeTimeZoneName';
+import { BasicFormatMatcher } from './BasicFormatMatcher';
+import { BestFitFormatMatcher } from './BestFitFormatMatcher';
+import { invariant } from '../utils';
+import { DATE_TIME_PROPS } from './utils';
+import { DateTimeStyleFormat } from './DateTimeStyleFormat';
+function isTimeRelated(opt) {
+    for (var _i = 0, _a = ['hour', 'minute', 'second']; _i < _a.length; _i++) {
+        var prop = _a[_i];
+        var value = opt[prop];
+        if (value !== undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+var TYPE_REGEX = /^[a-z0-9]{3,8}$/i;
+/**
+ * https://tc39.es/ecma402/#sec-initializedatetimeformat
+ * @param dtf DateTimeFormat
+ * @param locales locales
+ * @param opts options
+ */
+export function InitializeDateTimeFormat(dtf, locales, opts, _a) {
+    var getInternalSlots = _a.getInternalSlots, availableLocales = _a.availableLocales, localeData = _a.localeData, getDefaultLocale = _a.getDefaultLocale, getDefaultTimeZone = _a.getDefaultTimeZone, relevantExtensionKeys = _a.relevantExtensionKeys, tzData = _a.tzData, uppercaseLinks = _a.uppercaseLinks;
+    // @ts-ignore
+    var requestedLocales = CanonicalizeLocaleList(locales);
+    var options = ToDateTimeOptions(opts, 'any', 'date');
+    var opt = Object.create(null);
+    var matcher = GetOption(options, 'localeMatcher', 'string', ['lookup', 'best fit'], 'best fit');
+    opt.localeMatcher = matcher;
+    var calendar = GetOption(options, 'calendar', 'string', undefined, undefined);
+    if (calendar !== undefined && !TYPE_REGEX.test(calendar)) {
+        throw new RangeError('Malformed calendar');
+    }
+    var internalSlots = getInternalSlots(dtf);
+    opt.ca = calendar;
+    var numberingSystem = GetOption(options, 'numberingSystem', 'string', undefined, undefined);
+    if (numberingSystem !== undefined && !TYPE_REGEX.test(numberingSystem)) {
+        throw new RangeError('Malformed numbering system');
+    }
+    opt.nu = numberingSystem;
+    var hour12 = GetOption(options, 'hour12', 'boolean', undefined, undefined);
+    var hourCycle = GetOption(options, 'hourCycle', 'string', ['h11', 'h12', 'h23', 'h24'], undefined);
+    if (hour12 !== undefined) {
+        // @ts-ignore
+        hourCycle = null;
+    }
+    opt.hc = hourCycle;
+    var r = ResolveLocale(availableLocales, requestedLocales, opt, relevantExtensionKeys, localeData, getDefaultLocale);
+    internalSlots.locale = r.locale;
+    calendar = r.ca;
+    internalSlots.calendar = calendar;
+    internalSlots.hourCycle = r.hc;
+    internalSlots.numberingSystem = r.nu;
+    var dataLocale = r.dataLocale;
+    internalSlots.dataLocale = dataLocale;
+    var timeZone = options.timeZone;
+    if (timeZone !== undefined) {
+        timeZone = String(timeZone);
+        if (!IsValidTimeZoneName(timeZone, { tzData: tzData, uppercaseLinks: uppercaseLinks })) {
+            throw new RangeError('Invalid timeZoneName');
+        }
+        timeZone = CanonicalizeTimeZoneName(timeZone, { tzData: tzData, uppercaseLinks: uppercaseLinks });
+    }
+    else {
+        timeZone = getDefaultTimeZone();
+    }
+    internalSlots.timeZone = timeZone;
+    opt = Object.create(null);
+    opt.weekday = GetOption(options, 'weekday', 'string', ['narrow', 'short', 'long'], undefined);
+    opt.era = GetOption(options, 'era', 'string', ['narrow', 'short', 'long'], undefined);
+    opt.year = GetOption(options, 'year', 'string', ['2-digit', 'numeric'], undefined);
+    opt.month = GetOption(options, 'month', 'string', ['2-digit', 'numeric', 'narrow', 'short', 'long'], undefined);
+    opt.day = GetOption(options, 'day', 'string', ['2-digit', 'numeric'], undefined);
+    opt.hour = GetOption(options, 'hour', 'string', ['2-digit', 'numeric'], undefined);
+    opt.minute = GetOption(options, 'minute', 'string', ['2-digit', 'numeric'], undefined);
+    opt.second = GetOption(options, 'second', 'string', ['2-digit', 'numeric'], undefined);
+    opt.timeZoneName = GetOption(options, 'timeZoneName', 'string', ['short', 'long'], undefined);
+    var dataLocaleData = localeData[dataLocale];
+    var formats = dataLocaleData.formats[calendar];
+    matcher = GetOption(options, 'formatMatcher', 'string', ['basic', 'best fit'], 'best fit');
+    var dateStyle = GetOption(options, 'dateStyle', 'string', ['full', 'long', 'medium', 'short'], undefined);
+    internalSlots.dateStyle = dateStyle;
+    var timeStyle = GetOption(options, 'timeStyle', 'string', ['full', 'long', 'medium', 'short'], undefined);
+    internalSlots.timeStyle = timeStyle;
+    var bestFormat;
+    if (dateStyle === undefined && timeStyle === undefined) {
+        if (matcher === 'basic') {
+            bestFormat = BasicFormatMatcher(opt, formats);
+        }
+        else {
+            if (isTimeRelated(opt)) {
+                opt.hour12 =
+                    internalSlots.hourCycle === 'h11' ||
+                        internalSlots.hourCycle === 'h12';
+            }
+            bestFormat = BestFitFormatMatcher(opt, formats);
+        }
+    }
+    else {
+        for (var _i = 0, DATE_TIME_PROPS_1 = DATE_TIME_PROPS; _i < DATE_TIME_PROPS_1.length; _i++) {
+            var prop = DATE_TIME_PROPS_1[_i];
+            var p = opt[prop];
+            if (p !== undefined) {
+                throw new TypeError("Intl.DateTimeFormat can't set option " + prop + " when " + (dateStyle ? 'dateStyle' : 'timeStyle') + " is used");
+            }
+        }
+        bestFormat = DateTimeStyleFormat(dateStyle, timeStyle, dataLocaleData);
+    }
+    for (var prop in opt) {
+        var p = bestFormat[prop];
+        if (p !== undefined) {
+            internalSlots[prop] = p;
+        }
+    }
+    var pattern;
+    if (internalSlots.hour !== undefined) {
+        var hcDefault = dataLocaleData.hourCycle;
+        var hc = internalSlots.hourCycle;
+        if (hc == null) {
+            hc = hcDefault;
+        }
+        if (hour12 !== undefined) {
+            if (hour12) {
+                if (hcDefault === 'h11' || hcDefault === 'h23') {
+                    hc = 'h11';
+                }
+                else {
+                    hc = 'h12';
+                }
+            }
+            else {
+                invariant(!hour12, 'hour12 must not be set');
+                if (hcDefault === 'h11' || hcDefault === 'h23') {
+                    hc = 'h23';
+                }
+                else {
+                    hc = 'h24';
+                }
+            }
+        }
+        internalSlots.hourCycle = hc;
+        if (hc === 'h11' || hc === 'h12') {
+            pattern = bestFormat.pattern12;
+        }
+        else {
+            pattern = bestFormat.pattern;
+        }
+    }
+    else {
+        // @ts-ignore
+        internalSlots.hourCycle = undefined;
+        pattern = bestFormat.pattern;
+    }
+    internalSlots.pattern = pattern;
+    return dtf;
+}

package/lib/src/DateTimeFormat/PartitionDateTimePattern.d.ts

@@ -0,0 +1,13 @@
+import { IntlDateTimeFormatInternal, DateTimeFormatLocaleInternalData, UnpackedZoneData } from '../../types/date-time';
+/**
+ * https://tc39.es/ecma402/#sec-partitiondatetimepattern
+ * @param dtf
+ * @param x
+ */
+export declare function PartitionDateTimePattern(dtf: Intl.DateTimeFormat, x: number, { getInternalSlots, localeData, getDefaultTimeZone, tzData, }: {
+    getInternalSlots(dtf: Intl.DateTimeFormat): IntlDateTimeFormatInternal;
+    localeData: Record<string, DateTimeFormatLocaleInternalData>;
+    getDefaultTimeZone(): string;
+    tzData: Record<string, UnpackedZoneData[]>;
+}): Intl.DateTimeFormatPart[];
+//# sourceMappingURL=PartitionDateTimePattern.d.ts.map

package/lib/src/DateTimeFormat/PartitionDateTimePattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartitionDateTimePattern.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/PartitionDateTimePattern.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,gCAAgC,EAChC,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AA4C/B;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,CAAC,EAAE,MAAM,EACT,EACE,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,MAAM,GACP,EAAE;IACD,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,GAAG,0BAA0B,CAAC;IACvE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gCAAgC,CAAC,CAAC;IAC7D,kBAAkB,IAAI,MAAM,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;CAC5C,GACA,IAAI,CAAC,kBAAkB,EAAE,CA2I3B"}

package/lib/src/DateTimeFormat/PartitionDateTimePattern.js

@@ -0,0 +1,176 @@
+import { TimeClip } from '../../262';
+import { PartitionPattern } from '../PartitionPattern';
+import { DATE_TIME_PROPS } from './utils';
+import { ToLocalTime } from './ToLocalTime';
+function pad(n) {
+    if (n < 10) {
+        return "0" + n;
+    }
+    return String(n);
+}
+function offsetToGmtString(gmtFormat, hourFormat, offsetInMs, style) {
+    var offsetInMinutes = Math.floor(offsetInMs / 60000);
+    var mins = Math.abs(offsetInMinutes) % 60;
+    var hours = Math.floor(Math.abs(offsetInMinutes) / 60);
+    var _a = hourFormat.split(';'), positivePattern = _a[0], negativePattern = _a[1];
+    var offsetStr = '';
+    var pattern = offsetInMs < 0 ? negativePattern : positivePattern;
+    if (style === 'long') {
+        offsetStr = pattern
+            .replace('HH', pad(hours))
+            .replace('H', String(hours))
+            .replace('mm', pad(mins))
+            .replace('m', String(mins));
+    }
+    else if (mins || hours) {
+        if (!mins) {
+            pattern = pattern.replace(/:?m+/, '');
+        }
+        offsetStr = pattern
+            .replace(/H+/, String(hours))
+            .replace(/m+/, String(mins));
+    }
+    return gmtFormat.replace('{0}', offsetStr);
+}
+/**
+ * https://tc39.es/ecma402/#sec-partitiondatetimepattern
+ * @param dtf
+ * @param x
+ */
+export function PartitionDateTimePattern(dtf, x, _a) {
+    var getInternalSlots = _a.getInternalSlots, localeData = _a.localeData, getDefaultTimeZone = _a.getDefaultTimeZone, tzData = _a.tzData;
+    x = TimeClip(x);
+    if (isNaN(x)) {
+        throw new RangeError('invalid time');
+    }
+    /** IMPL START */
+    var internalSlots = getInternalSlots(dtf);
+    var dataLocale = internalSlots.dataLocale;
+    var dataLocaleData = localeData[dataLocale];
+    /** IMPL END */
+    var locale = internalSlots.locale;
+    var nfOptions = Object.create(null);
+    nfOptions.useGrouping = false;
+    var nf = new Intl.NumberFormat(locale, nfOptions);
+    var nf2Options = Object.create(null);
+    nf2Options.minimumIntegerDigits = 2;
+    nf2Options.useGrouping = false;
+    var nf2 = new Intl.NumberFormat(locale, nf2Options);
+    var tm = ToLocalTime(x, 
+    // @ts-ignore
+    internalSlots.calendar, internalSlots.timeZone, { tzData: tzData });
+    var result = [];
+    var patternParts = PartitionPattern(internalSlots.pattern);
+    for (var _i = 0, patternParts_1 = patternParts; _i < patternParts_1.length; _i++) {
+        var patternPart = patternParts_1[_i];
+        var p = patternPart.type;
+        if (p === 'literal') {
+            result.push({
+                type: 'literal',
+                value: patternPart.value,
+            });
+        }
+        else if (DATE_TIME_PROPS.indexOf(p) > -1) {
+            var fv = '';
+            var f = internalSlots[p];
+            // @ts-ignore
+            var v = tm[p];
+            if (p === 'year' && v <= 0) {
+                v = 1 - v;
+            }
+            if (p === 'month') {
+                v++;
+            }
+            var hourCycle = internalSlots.hourCycle;
+            if (p === 'hour' && (hourCycle === 'h11' || hourCycle === 'h12')) {
+                v = v % 12;
+                if (v === 0 && hourCycle === 'h12') {
+                    v = 12;
+                }
+            }
+            if (p === 'hour' && hourCycle === 'h24') {
+                if (v === 0) {
+                    v = 24;
+                }
+            }
+            if (f === 'numeric') {
+                fv = nf.format(v);
+            }
+            else if (f === '2-digit') {
+                fv = nf2.format(v);
+                if (fv.length > 2) {
+                    fv = fv.slice(fv.length - 2, fv.length);
+                }
+            }
+            else if (f === 'narrow' || f === 'short' || f === 'long') {
+                if (p === 'era') {
+                    fv = dataLocaleData[p][f][v];
+                }
+                else if (p === 'timeZoneName') {
+                    var timeZoneName = dataLocaleData.timeZoneName, gmtFormat = dataLocaleData.gmtFormat, hourFormat = dataLocaleData.hourFormat;
+                    var timeZone = internalSlots.timeZone || getDefaultTimeZone();
+                    var timeZoneData = timeZoneName[timeZone];
+                    if (timeZoneData && timeZoneData[f]) {
+                        fv = timeZoneData[f][+tm.inDST];
+                    }
+                    else {
+                        // Fallback to gmtFormat
+                        fv = offsetToGmtString(gmtFormat, hourFormat, tm.timeZoneOffset, f);
+                    }
+                }
+                else if (p === 'month') {
+                    fv = dataLocaleData.month[f][v - 1];
+                }
+                else {
+                    fv = dataLocaleData[p][f][v];
+                }
+            }
+            result.push({
+                type: p,
+                value: fv,
+            });
+        }
+        else if (p === 'ampm') {
+            var v = tm.hour;
+            var fv = void 0;
+            if (v > 11) {
+                fv = dataLocaleData.pm;
+            }
+            else {
+                fv = dataLocaleData.am;
+            }
+            result.push({
+                type: 'dayPeriod',
+                value: fv,
+            });
+        }
+        else if (p === 'relatedYear') {
+            var v = tm.relatedYear;
+            // @ts-ignore
+            var fv = nf.format(v);
+            result.push({
+                // @ts-ignore TODO: Fix TS type
+                type: 'relatedYear',
+                value: fv,
+            });
+        }
+        else if (p === 'yearName') {
+            var v = tm.yearName;
+            // @ts-ignore
+            var fv = nf.format(v);
+            result.push({
+                // @ts-ignore TODO: Fix TS type
+                type: 'yearName',
+                value: fv,
+            });
+        }
+        else {
+            result.push({
+                // @ts-ignore TODO: Fix TS type
+                type: 'unknown',
+                value: String(x),
+            });
+        }
+    }
+    return result;
+}

package/lib/src/DateTimeFormat/ToDateTimeOptions.d.ts

@@ -0,0 +1,9 @@
+import { DateTimeFormatOptions } from '../../types/date-time';
+/**
+ * https://tc39.es/ecma402/#sec-todatetimeoptions
+ * @param options
+ * @param required
+ * @param defaults
+ */
+export declare function ToDateTimeOptions(options?: DateTimeFormatOptions | null, required?: string, defaults?: string): DateTimeFormatOptions;
+//# sourceMappingURL=ToDateTimeOptions.d.ts.map

package/lib/src/DateTimeFormat/ToDateTimeOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToDateTimeOptions.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/DateTimeFormat/ToDateTimeOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAG5D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,qBAAqB,GAAG,IAAI,EACtC,QAAQ,CAAC,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,qBAAqB,CAyDvB"}