@primate/core 0.4.6 → 0.6.0

package/lib/private/i18n/Formatter.js

@@ -1,21 +1,22 @@
-import fail from "#fail";
+import E from "#i18n/errors";
 import ordinals from "#i18n/ordinals";
 import toIntlUnit from "#i18n/toIntlUnit";
-import is from "@rcompat/assert/is";
+import assert from "@rcompat/assert";
 export default class Formatter {
     #locale;
     constructor(locale) {
-        is(locale).string();
+        assert.string(locale);
         this.#locale = locale;
     }
     get locale() {
         return this.#locale;
     }
     set locale(locale) {
-        is(locale).string();
+        assert.string(locale);
         this.#locale = locale;
     }
     number(number) {
+        assert.number(number);
         try {
             return new Intl.NumberFormat(this.#locale).format(number);
         }
@@ -24,6 +25,7 @@ export default class Formatter {
         }
     }
     date(date) {
+        assert.date(date);
         try {
             return new Intl.DateTimeFormat(this.#locale).format(date);
         }
@@ -32,6 +34,8 @@ export default class Formatter {
         }
     }
     currency(currency, amount) {
+        assert.string(currency);
+        assert.number(amount);
         const options = { style: "currency", currency };
         try {
             return new Intl.NumberFormat(this.#locale, options).format(amount);
@@ -41,6 +45,7 @@ export default class Formatter {
         }
     }
     ordinal(number) {
+        assert.number(number);
         try {
             const n = Math.trunc(number);
             const rules = new Intl.PluralRules(this.#locale, { type: "ordinal" });
@@ -58,9 +63,14 @@ export default class Formatter {
         }
     }
     relative(milliseconds, options) {
-        const defaults = { numeric: "auto", style: "long", ...options };
+        assert.number(milliseconds);
+        assert.maybe.dict(options);
+        assert.maybe.string(options?.numeric);
+        assert.maybe.string(options?.style);
+        const numeric = options?.numeric ?? "auto";
+        const style = options?.style ?? "long";
         try {
-            const rtf = new Intl.RelativeTimeFormat(this.#locale, defaults);
+            const rtf = new Intl.RelativeTimeFormat(this.#locale, { numeric, style });
             const s = Math.round(milliseconds / 1000);
             const abs = Math.abs(s);
             if (abs >= 31536000)
@@ -82,6 +92,7 @@ export default class Formatter {
         }
     }
     list(items) {
+        assert.array(items);
         try {
             return new Intl.ListFormat(this.#locale).format(items);
         }
@@ -90,9 +101,10 @@ export default class Formatter {
         }
     }
     unit(value, u) {
-        const unit = toIntlUnit(u);
-        if (unit === undefined)
-            throw fail("unit {0} not supported", u);
+        assert.number(value);
+        assert.string(u);
+        const intl_unit = toIntlUnit(u);
+        const unit = assert.defined(intl_unit, E.unit_not_supported(u));
         const options = { style: "unit", unit };
         try {
             return new Intl.NumberFormat(this.#locale, options).format(value);

package/lib/private/i18n/errors.d.ts

@@ -0,0 +1,16 @@
+declare function unit_not_supported(unit: string): import("@rcompat/error").TemplateError;
+declare function at_least_one_locale(): import("@rcompat/error").TemplateError;
+declare function missing_default_locale(locales: string[]): import("@rcompat/error").TemplateError;
+declare function unused_default_locale(locale: string, locales: string[]): import("@rcompat/error").TemplateError;
+declare function no_dots_catalog_keys(key: string, at: string, locale: string): import("@rcompat/error").TemplateError;
+declare const errors: {
+    at_least_one_locale: typeof at_least_one_locale;
+    missing_default_locale: typeof missing_default_locale;
+    unused_default_locale: typeof unused_default_locale;
+    unit_not_supported: typeof unit_not_supported;
+    no_dots_catalog_keys: typeof no_dots_catalog_keys;
+};
+export type Code = keyof typeof errors;
+export declare const Code: { [K in Code]: K; };
+export default errors;
+//# sourceMappingURL=errors.d.ts.map

package/lib/private/i18n/errors.js

@@ -0,0 +1,27 @@
+import error from "@rcompat/error";
+const t = error.template;
+function unit_not_supported(unit) {
+    return t `unit ${unit} not supported`;
+}
+function at_least_one_locale() {
+    return t `must have at least 1 locale`;
+}
+function missing_default_locale(locales) {
+    return t `missing default locale, locales: ${locales}`;
+}
+function unused_default_locale(locale, locales) {
+    return t `default locale ${locale} not in locales ${locales}`;
+}
+function no_dots_catalog_keys(key, at, locale) {
+    return t `dots are not allowed in catalog key names. Found ${key} at ${at} (locale ${locale})`;
+}
+const errors = error.coded({
+    at_least_one_locale,
+    missing_default_locale,
+    unused_default_locale,
+    unit_not_supported,
+    no_dots_catalog_keys,
+});
+export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export default errors;
+//# sourceMappingURL=errors.js.map

package/lib/private/i18n/format.d.ts

@@ -0,0 +1,4 @@
+import type Formatter from "#i18n/Formatter";
+import type { Dict } from "@rcompat/type";
+export default function format(input: string, params: Dict, currency: string, formatter: Formatter): string;
+//# sourceMappingURL=format.d.ts.map

package/lib/private/i18n/format.js

@@ -0,0 +1,95 @@
+import is from "@rcompat/is";
+export default function format(input, params, currency, formatter) {
+    let template = input;
+    // save escaped braces
+    template = template.replace(/\{\{/g, "\uE000");
+    template = template.replace(/\}\}/g, "\uE001");
+    // Process normal parameters with nested brace support
+    const template_re = /\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+    template = template.replace(template_re, (_, body) => {
+        // name[:spec]
+        let name = body;
+        let spec;
+        const colon = body.indexOf(":");
+        if (colon >= 0) {
+            name = body.slice(0, colon);
+            spec = body.slice(colon + 1);
+        }
+        const value = params[name];
+        if (!spec)
+            return value == null ? "" : String(value);
+        // number selection: "n|one|other" or "n|zero|one|other"
+        const bar = spec.indexOf("|");
+        const head = (bar === -1 ? spec : spec.slice(0, bar)).toLowerCase();
+        const tail = bar === -1 ? "" : spec.slice(bar + 1);
+        // units u(...)/unit(...)
+        const m = /^(?:u|unit)\(([^)]+)\)$/.exec(head);
+        if (m)
+            return formatter.unit(Number(value ?? 0), m[1]);
+        switch (head) {
+            case "n":
+            case "number": {
+                if (tail) {
+                    const options = tail.split("|");
+                    const n = Number(value ?? 0);
+                    const formatted = formatter.number(n);
+                    const plural = () => {
+                        const category = Number.isFinite(n)
+                            ? formatter.pluralRules().select(n)
+                            : "other";
+                        if (options.length === 2) {
+                            const [one, other] = options;
+                            return category === "one" ? one : other;
+                        }
+                        if (options.length === 3) {
+                            const [zero, one, other] = options;
+                            return n === 0 ? zero : (category === "one" ? one : other);
+                        }
+                        if (options.length === 5) {
+                            const [zero, one, few, many, other] = options;
+                            if (n === 0)
+                                return zero;
+                            switch (category) {
+                                case "one": return one;
+                                case "few": return few;
+                                case "many": return many;
+                                default: return other;
+                            }
+                        }
+                        return formatted;
+                    };
+                    return plural().replace(new RegExp(`\\{${name}\\}`, "g"), formatted);
+                }
+                return formatter.number(Number(value ?? 0));
+            }
+            case "d":
+            case "date": {
+                const d = is.number(value)
+                    ? new Date(value)
+                    : is.date(value)
+                        ? value
+                        : new Date(NaN);
+                return formatter.date(d);
+            }
+            case "c":
+            case "currency":
+                return formatter.currency(currency, Number(value ?? 0));
+            case "o":
+            case "ordinal":
+                return formatter.ordinal(Number(value ?? 0));
+            case "a":
+            case "ago":
+                return formatter.relative(Number(value ?? 0));
+            case "l":
+            case "list":
+                return formatter.list(Array.isArray(value) ? value : []);
+            default:
+                return value == null ? "" : String(value);
+        }
+    });
+    // restore escaped braces
+    template = template.replace(/\uE000/g, "{");
+    template = template.replace(/\uE001/g, "}");
+    return template;
+}
+//# sourceMappingURL=format.js.map