@stamcat/localize 1.0.4

package/index.d.ts

@@ -0,0 +1,3 @@
+import { Localize, createLocalize } from "./src/localize";
+export { createLocalize };
+export default Localize;

package/index.js

@@ -0,0 +1,3 @@
+import { Localize, createLocalize } from "./src/localize";
+export { createLocalize };
+export default Localize;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@stamcat/localize",
+  "version": "1.0.4",
+  "description": "A collection of localization tools built on FormatJS & i18n",
+  "main": "index.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Stamcat/Localize.git"
+  },
+  "keywords": [
+    "formatjs",
+    "i18n",
+    "internationalization",
+    "localization"
+  ],
+  "author": "Devin Marra",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Stamcat/Localize/issues"
+  },
+  "homepage": "https://github.com/Stamcat/Localize#readme",
+  "scripts": {},
+  "dependencies": {
+    "flat": "6.0.1",
+    "react-intl": "10.1.13"
+  },
+  "devDependencies": {},
+  "lint-staged": {
+    "package-lock.json": "node qualityChecks/check-package-lock.cjs",
+    "*.json": "npm run pretty:commit --",
+    "src/*.{ts,tsx,js}|*.{ts,tsx}": [
+      "npm run lint:commit --fix --silent --"
+    ]
+  }
+}

package/src/cache.d.ts

@@ -0,0 +1,2 @@
+export declare function runWithCache<T>(fn: () => T): T;
+export declare function cache<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;

package/src/cache.js

@@ -0,0 +1,51 @@
+let als = null;
+try {
+    const { AsyncLocalStorage } = require("async_hooks");
+    als = new AsyncLocalStorage();
+}
+catch {
+}
+const globalStore = new Map();
+function getCurrentStore() {
+    return als?.getStore() ?? globalStore;
+}
+export function runWithCache(fn) {
+    if (als) {
+        return als.run(new Map(), fn);
+    }
+    return fn();
+}
+export function cache(fn) {
+    return (...args) => {
+        const store = getCurrentStore();
+        let node = store.get(fn);
+        if (!node) {
+            node = { children: new Map() };
+            store.set(fn, node);
+        }
+        let current = node;
+        for (const arg of args) {
+            let child = current.children.get(arg);
+            if (!child) {
+                child = { children: new Map() };
+                current.children.set(arg, child);
+            }
+            current = child;
+        }
+        if (current.entry) {
+            if (current.entry.status === "fulfilled") {
+                return current.entry.value;
+            }
+            throw current.entry.reason;
+        }
+        try {
+            const value = fn(...args);
+            current.entry = { status: "fulfilled", value };
+            return value;
+        }
+        catch (reason) {
+            current.entry = { status: "rejected", reason };
+            throw reason;
+        }
+    };
+}

package/src/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const localeMap: {
+    [key: string]: string;
+};
+export declare const intlOverrideMap: {
+    [name: string]: string;
+};

package/src/constants.js

@@ -0,0 +1,161 @@
+export const localeMap = {
+    ar: "ar-IL",
+    "ar-IL": "ar-IL",
+    az: "az",
+    "az-AZ": "az",
+    bg: "bg",
+    "bg-BG": "bg",
+    cs: "cs",
+    "cs-CZ": "cs",
+    da: "da-DK",
+    "da-DK": "da",
+    de: "de",
+    "de-AT": "de-AT",
+    "de-CH": "de-CH",
+    "de-DE": "de",
+    el: "el",
+    "el-CY": "el-CY",
+    "el-GR": "el",
+    en: "en-US",
+    "en-AU": "en-AU",
+    "en-BW": "en-BW",
+    "en-CA": "en-CA",
+    "en-GB": "en-GB",
+    "en-GH": "en-GH",
+    "en-HK": "en-HK",
+    "en-ID": "en-US",
+    "en-IE": "en-IE",
+    "en-IN": "en-IN",
+    "en-JM": "en-JM",
+    "en-KH": "en-KH",
+    "en-LB": "en-US",
+    "en-LS": "en-LS",
+    "en-MT": "en-MT",
+    "en-MY": "en-MY",
+    "en-NA": "en-NA",
+    "en-NZ": "en-NZ",
+    "en-PH": "en-PH",
+    "en-SG": "en-SG",
+    "en-SZ": "en-SZ",
+    "en-TT": "en-TT",
+    "en-US": "en-US",
+    "en-US-POSIX": "en-US",
+    "en-ZA": "en-ZA",
+    "en-ZM": "en-ZM",
+    es: "es",
+    "es-AR": "es-AR",
+    "es-AW": "es-AW",
+    "es-BO": "es-BO",
+    "es-CL": "es-CL",
+    "es-CO": "es-CO",
+    "es-CR": "es-CR",
+    "es-DO": "es-DO",
+    "es-EC": "es-EC",
+    "es-ES": "es",
+    "es-GT": "es-GT",
+    "es-HN": "es-HN",
+    "es-MX": "es-MX",
+    "es-NI": "es-NI",
+    "es-PA": "es-PA",
+    "es-PE": "es-PE",
+    "es-PR": "es-PR",
+    "es-PY": "es-PY",
+    "es-SV": "es-SV",
+    "es-US": "es-US",
+    "es-UY": "es-UY",
+    "es-VE": "es-VE",
+    et: "et",
+    "et-EE": "et",
+    fi: "fi",
+    "fi-FI": "fi",
+    fr: "fr",
+    "fr-BE": "fr-BE",
+    "fr-CA": "fr-CA",
+    "fr-CH": "fr-CH",
+    "fr-FR": "fr",
+    "fr-PF": "fr-PF",
+    he: "he",
+    "he-IL": "he",
+    hi: "hi",
+    "hi-IN": "hi",
+    hr: "hr",
+    "hr-BA": "hr-BA",
+    "hr-HR": "hr",
+    hu: "hu",
+    "hu-HU": "hu",
+    hy: "hy",
+    "hy-AM": "hy",
+    id: "id",
+    "id-ID": "id",
+    is: "is",
+    "is-IS": "is",
+    it: "it",
+    "it-CH": "it-CH",
+    "it-IT": "it",
+    ja: "ja",
+    "ja-JP": "ja",
+    ka: "ka",
+    "ka-GE": "ka",
+    km: "km",
+    "km-KH": "km",
+    ko: "ko",
+    "ko-KR": "ko",
+    lt: "lt",
+    "lt-LT": "lt",
+    lv: "lv",
+    "lv-LV": "lv",
+    mk: "mk",
+    "mk-MK": "mk",
+    mn: "mn",
+    "mn-NM": "mn",
+    ms: "ms-MY",
+    "ms-MY": "ms",
+    nl: "nl",
+    "nl-BE": "nl-BE",
+    "nl-NL": "nl",
+    nn: "nn",
+    "nn-NO": "nn-NO",
+    pl: "pl",
+    "pl-PL": "pl",
+    pt: "pt",
+    "pt-BR": "pt",
+    "pt-PT": "pt-PT",
+    ro: "ro",
+    "ro-MD": "ro-MD",
+    "ro-RO": "ro",
+    ru: "ru",
+    "ru-BY": "ru-BY",
+    "ru-IL": "ru-IL",
+    "ru-KG": "ru-KG",
+    "ru-KZ": "ru-KZ",
+    "ru-RU": "ru",
+    "ru-UZ": "ru-UZ",
+    sk: "sk",
+    "sk-SK": "sk",
+    sl: "sl",
+    "sl-SI": "sl",
+    sr: "sr",
+    "sr-RS": "sr",
+    sv: "sv",
+    "sv-FI": "sv",
+    "sv-SE": "sv",
+    th: "th",
+    "th-TH": "th",
+    tr: "tr",
+    "tr-TR": "tr",
+    uk: "uk",
+    "uk-UA": "uk",
+    uz: "uz",
+    "uz-UZ": "uz",
+    vi: "vi",
+    "vi-VN": "vi",
+    "zh-HK": "zh-HK",
+    "zh-MO": "zh-MO",
+    "zh-MY": "zh-MY",
+    zh: "zh-TW",
+    "zh-TW": "zh-TW",
+};
+export const intlOverrideMap = {
+    "es-US": "es-PR",
+    "sr-RS": "sr-latn",
+};

package/src/intl.d.ts

@@ -0,0 +1,11 @@
+import { IntlShape } from "react-intl";
+import { LocalizeInstance } from "./storage";
+export type IntlFunctions = {
+    appIntl: () => IntlShape;
+    overrideAppIntl: () => IntlShape;
+    appIntlFormatOverride: () => IntlShape;
+};
+export declare function createIntlFunctions(localeInstance: LocalizeInstance): IntlFunctions;
+export declare const appIntl: () => IntlShape;
+export declare const overrideAppIntl: () => IntlShape;
+export declare const appIntlFormatOverride: () => IntlShape;

package/src/intl.js

@@ -0,0 +1,56 @@
+import { createIntl, createIntlCache } from "react-intl";
+import { intlOverrideMap, localeMap } from "./constants";
+import { Locale } from "./storage";
+import { flatten } from "flat";
+let flattenedMessages = {};
+const getMessages = (locale, delimiter = "/", getAllTranslations) => {
+    if (getAllTranslations) {
+        const f = flatten(getAllTranslations(), { delimiter });
+        return f;
+    }
+    const currentLocale = localeMap[locale];
+    if (!flattenedMessages[currentLocale]) {
+        const allMessages = Locale.getAllTranslations();
+        const fetchedMessages = allMessages;
+        const f = flatten(fetchedMessages, {
+            delimiter,
+        });
+        flattenedMessages = {
+            [locale]: f,
+        };
+    }
+    return flattenedMessages[locale];
+};
+export function createIntlFunctions(localeInstance) {
+    let intl;
+    let intlOverride;
+    const appIntl = () => {
+        const l = localeInstance.getLocale();
+        if (!intl || intl.locale !== l) {
+            const m = getMessages(l, "/", localeInstance.getAllTranslations);
+            intl = createIntl({
+                locale: l,
+                messages: m,
+            }, createIntlCache());
+        }
+        return intl;
+    };
+    const overrideAppIntl = () => {
+        if (!intlOverride) {
+            const l = localeInstance.getLocale();
+            intlOverride = createIntl({
+                locale: intlOverrideMap[l] || `${l}-u-nu-latn`,
+            }, createIntlCache());
+        }
+        return intlOverride;
+    };
+    const appIntlFormatOverride = () => {
+        const l = localeInstance.getLocale();
+        return intlOverrideMap[l] ? overrideAppIntl() : appIntl();
+    };
+    return { appIntl, overrideAppIntl, appIntlFormatOverride };
+}
+const _singletonIntl = createIntlFunctions(Locale);
+export const appIntl = _singletonIntl.appIntl;
+export const overrideAppIntl = _singletonIntl.overrideAppIntl;
+export const appIntlFormatOverride = _singletonIntl.appIntlFormatOverride;

package/src/localize.d.ts

@@ -0,0 +1,53 @@
+import { FormatNumberOptions, FormatDateOptions, MessageDescriptor, PrimitiveType } from "react-intl";
+import { Formats, FormatXMLElementFn } from "intl-messageformat";
+import { IntlMessageFormatOptions } from "./types";
+export declare function createLocalize(defaultLocale?: string): {
+    getLocale: () => string;
+    setLocale: (newLocale: string) => void;
+    getCountryCode: () => string;
+    getLanguageCode: () => string;
+    pending: {
+        get: (key: string) => Promise<void> | undefined;
+        set: (key: string, value: Promise<void>) => void;
+        delete: (key: string) => void;
+        has: (key: string) => boolean;
+        clear: () => void;
+    };
+    getAllMessages: () => Record<string, unknown>;
+    prepareMessages: (locale: string, fetchedMessages: object, delimiter?: string) => Record<string, string>;
+    appendMessages: (newMessages: Record<string, unknown>) => void;
+    setTranslations: (newMessages: Record<string, unknown>) => void;
+    changeLocale: (newLocale: string, messages?: object, delimiter?: string) => void;
+    getMeasureFormat: (locale?: string) => "metric" | "imperial";
+    getCountryName: (locale: string, localizedTo?: string) => string;
+    formatDate: (value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions) => string;
+    formatDateRange: (from: Parameters<Intl.DateTimeFormat["format"]>[0] | string, to: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: any) => string;
+    formatMessage: (id: string, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, descriptor?: MessageDescriptor, opts?: IntlMessageFormatOptions) => string;
+    message: (message: string, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, overrideFormats?: Partial<Formats>, opts?: IntlMessageFormatOptions) => string | string[];
+    formatNumber: (value: Parameters<Intl.NumberFormat["format"]>[0], opts?: FormatNumberOptions) => string;
+};
+export declare const Localize: {
+    getLocale: () => string;
+    setLocale: (newLocale: string) => void;
+    getCountryCode: () => string;
+    getLanguageCode: () => string;
+    pending: {
+        get: (key: string) => Promise<void> | undefined;
+        set: (key: string, value: Promise<void>) => void;
+        delete: (key: string) => void;
+        has: (key: string) => boolean;
+        clear: () => void;
+    };
+    getAllMessages: () => Record<string, unknown>;
+    prepareMessages: (locale: string, fetchedMessages: object, delimiter?: string) => Record<string, string>;
+    appendMessages: (newMessages: Record<string, unknown>) => void;
+    setTranslations: (newMessages: Record<string, unknown>) => void;
+    changeLocale: (newLocale: string, messages?: object, delimiter?: string) => void;
+    getMeasureFormat: (locale?: string) => "metric" | "imperial";
+    getCountryName: (locale: string, localizedTo?: string) => string;
+    formatDate: (value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions) => string;
+    formatDateRange: (from: Parameters<Intl.DateTimeFormat["format"]>[0] | string, to: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: any) => string;
+    formatMessage: (id: string, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, descriptor?: MessageDescriptor, opts?: IntlMessageFormatOptions) => string;
+    message: (message: string, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, overrideFormats?: Partial<Formats>, opts?: IntlMessageFormatOptions) => string | string[];
+    formatNumber: (value: Parameters<Intl.NumberFormat["format"]>[0], opts?: FormatNumberOptions) => string;
+};

package/src/localize.js

@@ -0,0 +1,108 @@
+import { IntlMessageFormat } from "intl-messageformat";
+import { createIntlFunctions } from "./intl";
+import { flatten } from "flat";
+import { createLocalizeInstance } from "./storage";
+import { localeMap } from "./constants";
+export function createLocalize(defaultLocale = "en-US") {
+    const localeInstance = createLocalizeInstance(defaultLocale);
+    const { appIntl, appIntlFormatOverride } = createIntlFunctions(localeInstance);
+    const instance = {
+        getLocale: () => localeInstance.getLocale(),
+        setLocale: (newLocale) => {
+            localeInstance.setLocale(newLocale);
+        },
+        getCountryCode: () => localeInstance.getCountryCode(),
+        getLanguageCode: () => localeInstance.getLanguageCode(),
+        pending: {
+            get: (key) => localeInstance.getPending(key),
+            set: (key, value) => localeInstance.setPending(key, value),
+            delete: (key) => localeInstance.deletePending(key),
+            has: (key) => localeInstance.hasPending(key),
+            clear: () => localeInstance.clearPending(),
+        },
+        getAllMessages: () => localeInstance.getAllTranslations(),
+        prepareMessages: (locale, fetchedMessages, delimiter) => {
+            let flattenedMessages = {};
+            const currentLocale = localeMap[locale];
+            if (!flattenedMessages[currentLocale]) {
+                const f = flatten(fetchedMessages, {
+                    delimiter,
+                });
+                flattenedMessages = {
+                    [locale]: f,
+                };
+            }
+            return flattenedMessages[locale];
+        },
+        appendMessages: (newMessages) => {
+            const messages = localeInstance.getAllTranslations();
+            localeInstance.setTranslations({ ...messages, ...newMessages });
+        },
+        setTranslations: (newMessages) => {
+            localeInstance.setTranslations(newMessages);
+        },
+        changeLocale: (newLocale, messages, delimiter) => {
+            localeInstance.setLocale(newLocale);
+            if (messages) {
+                const newMessages = instance.prepareMessages(newLocale, messages, delimiter);
+                localeInstance.setTranslations(newMessages);
+            }
+        },
+        getMeasureFormat: (locale) => {
+            const l = locale || instance.getLocale();
+            const region = new Intl.Locale(l).region;
+            const imperialRegions = ["US", "LR", "MM"];
+            return imperialRegions.includes(region || "US") ? "imperial" : "metric";
+        },
+        getCountryName: (locale, localizedTo) => {
+            const parts = locale.split("-");
+            const region = parts.length > 1 ? parts[1].toUpperCase() : "";
+            try {
+                const displayLocale = Intl.DisplayNames.supportedLocalesOf([localizedTo || locale])[0] || instance.getLocale();
+                const displayNames = new Intl.DisplayNames([displayLocale], {
+                    type: "region",
+                });
+                return displayNames.of(region) || region;
+            }
+            catch {
+                return region;
+            }
+        },
+        formatDate: (value, opts) => {
+            const intl = appIntlFormatOverride();
+            if (!value) {
+                return "";
+            }
+            return intl.formatDate(value, opts);
+        },
+        formatDateRange: (from, to, opts) => {
+            const intl = appIntlFormatOverride();
+            if (!from || !to) {
+                return "";
+            }
+            return intl.formatDateTimeRange(from, to, opts);
+        },
+        formatMessage: (id, values, descriptor, opts) => {
+            const nodeEnv = globalThis.process?.env?.NODE_ENV;
+            if (nodeEnv === "test") {
+                return id;
+            }
+            const intl = appIntl();
+            if (!id) {
+                return "";
+            }
+            return intl.formatMessage({ id, ...descriptor }, values, opts);
+        },
+        message: (message, values, overrideFormats, opts) => {
+            const locale = localeInstance.getLocale();
+            const msg = new IntlMessageFormat(message, locale, overrideFormats, opts);
+            return msg.format(values);
+        },
+        formatNumber: (value, opts) => {
+            const intl = appIntlFormatOverride();
+            return intl.formatNumber(value, opts);
+        },
+    };
+    return instance;
+}
+export const Localize = createLocalize();

package/src/storage.d.ts

@@ -0,0 +1,20 @@
+export type LocalizeStore = {
+    locale: string;
+    messages: Record<string, unknown>;
+    pending: Map<string, Promise<void>>;
+};
+export type LocalizeInstance = {
+    getLocale: () => string;
+    setLocale: (newLocale: string) => void;
+    getAllTranslations: () => Record<string, unknown>;
+    setTranslations: (newMessages: Record<string, unknown>) => void;
+    getCountryCode: () => string;
+    getLanguageCode: () => string;
+    getPending: (key: string) => Promise<void> | undefined;
+    setPending: (key: string, value: Promise<void>) => void;
+    deletePending: (key: string) => void;
+    hasPending: (key: string) => boolean;
+    clearPending: () => void;
+};
+export declare function createLocalizeInstance(defaultLocale?: string): LocalizeInstance;
+export declare const Locale: LocalizeInstance;

package/src/storage.js

@@ -0,0 +1,39 @@
+import { cache } from "./cache";
+export function createLocalizeInstance(defaultLocale = "en-US") {
+    const storeCache = cache(() => ({
+        locale: defaultLocale,
+        messages: {},
+        pending: new Map(),
+    }));
+    const store = storeCache();
+    return {
+        getLocale: () => store.locale,
+        setLocale: (newLocale) => {
+            store.locale = newLocale;
+        },
+        getAllTranslations: () => store.messages,
+        setTranslations: (newMessages) => {
+            store.messages = newMessages;
+        },
+        getPending: (key) => store.pending.get(key),
+        setPending: (key, value) => {
+            store.pending.set(key, value);
+        },
+        deletePending: (key) => {
+            store.pending.delete(key);
+        },
+        hasPending: (key) => store.pending.has(key),
+        clearPending: () => {
+            store.pending.clear();
+        },
+        getCountryCode: () => {
+            const parts = store.locale.split("-");
+            return parts.length > 1 ? parts[1].toUpperCase() : "US";
+        },
+        getLanguageCode: () => {
+            const parts = store.locale.split("-");
+            return parts[0].toLowerCase();
+        },
+    };
+}
+export const Locale = createLocalizeInstance();

package/src/types.d.ts

@@ -0,0 +1,13 @@
+import { Options } from "intl-messageformat";
+import { MessageFormatElement } from "react-intl";
+export type IntlMessageFormatOptions = Options;
+export type IntlMessage = Record<string, string> | Record<string, MessageFormatElement[]> | undefined;
+export type LegacyRaw = "dd'.'MM'.'yyyy" | "dd'/'MM'/'yy" | "dd'/'MM'/'yyyy" | "M'/'d'/'yy" | "M'/'d'/'yyyy" | "MMM d 'd.'" | "MMMM Y" | "dd MMMM, yyyy" | "d MMMM" | "d'/'M'/'yyyy" | "yyyy'-'MM'-'dd";
+export type LegacySkeleton = "MMMMd" | "MMMd" | "yMMdd" | "yMd";
+export type LegacyDate = "full" | "long" | "medium" | "short";
+export type LegacyDateFormat = {
+    date?: LegacyDate;
+    raw?: LegacyRaw;
+    skeleton?: LegacySkeleton;
+};
+export type LegacyDateFormats = LegacyRaw & LegacyDate & LegacySkeleton;

package/src/types.js

@@ -0,0 +1 @@
+export {};