@nascentdigital/funnel-core 4.4.4

package/dist/regionalization/Language.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Language = void 0;
+const errors_1 = require("../errors");
+// extension
+var Language;
+(function (Language) {
+    // mapping
+    Language.map = {
+        aa: 'Afar',
+        ab: 'Abkhaz',
+        ae: 'Avestan',
+        af: 'Afrikaans',
+        ak: 'Akan',
+        am: 'Amharic',
+        an: 'Aragonese',
+        ar: 'Arabic',
+        as: 'Assamese',
+        av: 'Avaric',
+        ay: 'Aymara',
+        az: 'Azerbaijani',
+        ba: 'Bashkir',
+        be: 'Belarusian',
+        bg: 'Bulgarian',
+        bh: 'Bihari',
+        bi: 'Bislama',
+        bm: 'Bambara',
+        bn: 'Bengali',
+        bo: 'Tibetan Standard',
+        br: 'Breton',
+        bs: 'Bosnian',
+        ca: 'Catalan',
+        ce: 'Chechen',
+        ch: 'Chamorro',
+        co: 'Corsican',
+        cr: 'Cree',
+        cs: 'Czech',
+        cu: 'Old Church Slavonic',
+        cv: 'Chuvash',
+        cy: 'Welsh',
+        da: 'Danish',
+        de: 'German',
+        dv: 'Divehi',
+        dz: 'Dzongkha',
+        ee: 'Ewe',
+        el: 'Greek',
+        en: 'English',
+        eo: 'Esperanto',
+        es: 'Spanish',
+        et: 'Estonian',
+        eu: 'Basque',
+        fa: 'Persian',
+        ff: 'Fula',
+        fi: 'Finnish',
+        fj: 'Fijian',
+        fo: 'Faroese',
+        fr: 'French',
+        fy: 'Western Frisian',
+        ga: 'Irish',
+        gd: 'Scottish Gaelic',
+        gl: 'Galician',
+        gn: 'Guaraní',
+        gu: 'Gujarati',
+        gv: 'Manx',
+        ha: 'Hausa',
+        he: 'Hebrew',
+        hi: 'Hindi',
+        ho: 'Hiri Motu',
+        hr: 'Croatian',
+        ht: 'Haitian',
+        hu: 'Hungarian',
+        hy: 'Armenian',
+        hz: 'Herero',
+        ia: 'Interlingua',
+        id: 'Indonesian',
+        ie: 'Interlingue',
+        ig: 'Igbo',
+        ii: 'Nuosu',
+        ik: 'Inupiaq',
+        io: 'Ido',
+        is: 'Icelandic',
+        it: 'Italian',
+        iu: 'Inuktitut',
+        ja: 'Japanese',
+        jv: 'Javanese',
+        ka: 'Georgian',
+        kg: 'Kongo',
+        ki: 'Kikuyu',
+        kj: 'Kwanyama',
+        kk: 'Kazakh',
+        kl: 'Kalaallisut',
+        km: 'Khmer',
+        kn: 'Kannada',
+        ko: 'Korean',
+        kr: 'Kanuri',
+        ks: 'Kashmiri',
+        ku: 'Kurdish',
+        kv: 'Komi',
+        kw: 'Cornish',
+        ky: 'Kyrgyz',
+        la: 'Latin',
+        lb: 'Luxembourgish',
+        lg: 'Ganda',
+        li: 'Limburgish',
+        ln: 'Lingala',
+        lo: 'Lao',
+        lt: 'Lithuanian',
+        lu: 'Luba-Katanga',
+        lv: 'Latvian',
+        mg: 'Malagasy',
+        mh: 'Marshallese',
+        mi: 'Māori',
+        mk: 'Macedonian',
+        ml: 'Malayalam',
+        mn: 'Mongolian',
+        mr: 'Marathi',
+        ms: 'Malay',
+        mt: 'Maltese',
+        my: 'Burmese',
+        na: 'Nauru',
+        nb: 'Norwegian Bokmål',
+        nd: 'Northern Ndebele',
+        ne: 'Nepali',
+        ng: 'Ndonga',
+        nl: 'Dutch',
+        nn: 'Norwegian Nynorsk',
+        no: 'Norwegian',
+        nr: 'Southern Ndebele',
+        nv: 'Navajo',
+        ny: 'Chichewa',
+        oc: 'Occitan',
+        oj: 'Ojibwe',
+        om: 'Oromo',
+        or: 'Oriya',
+        os: 'Ossetian',
+        pa: 'Panjabi',
+        pi: 'Pāli',
+        pl: 'Polish',
+        ps: 'Pashto',
+        pt: 'Portuguese',
+        qu: 'Quechua',
+        rm: 'Romansh',
+        rn: 'Kirundi',
+        ro: 'Romanian',
+        ru: 'Russian',
+        rw: 'Kinyarwanda',
+        sa: 'Sanskrit',
+        sc: 'Sardinian',
+        sd: 'Sindhi',
+        se: 'Northern Sami',
+        sg: 'Sango',
+        si: 'Sinhala',
+        sk: 'Slovak',
+        sl: 'Slovene',
+        sm: 'Samoan',
+        sn: 'Shona',
+        so: 'Somali',
+        sq: 'Albanian',
+        sr: 'Serbian',
+        ss: 'Swati',
+        st: 'Southern Sotho',
+        su: 'Sundanese',
+        sv: 'Swedish',
+        sw: 'Swahili',
+        ta: 'Tamil',
+        te: 'Telugu',
+        tg: 'Tajik',
+        th: 'Thai',
+        ti: 'Tigrinya',
+        tk: 'Turkmen',
+        tl: 'Tagalog',
+        tn: 'Tswana',
+        to: 'Tonga',
+        tr: 'Turkish',
+        ts: 'Tsonga',
+        tt: 'Tatar',
+        tw: 'Twi',
+        ty: 'Tahitian',
+        ug: 'Uyghur',
+        uk: 'Ukrainian',
+        ur: 'Urdu',
+        uz: 'Uzbek',
+        ve: 'Venda',
+        vi: 'Vietnamese',
+        vo: 'Volapük',
+        wa: 'Walloon',
+        wo: 'Wolof',
+        xh: 'Xhosa',
+        yi: 'Yiddish',
+        yo: 'Yoruba',
+        za: 'Zhuang',
+        zh: 'Chinese',
+        zu: 'Zulu',
+    };
+    // values
+    Language.values = Object.keys(Language.map);
+    Language.fallback = 'en';
+    // helpers
+    function getName(language) {
+        return Language.map[language];
+    }
+    Language.getName = getName;
+    function filter(value) {
+        return typeof value === 'string'
+            && !!Language.map[value];
+    }
+    Language.filter = filter;
+    function guard(value) {
+        // pass if filtered
+        if (filter(value)) {
+            return true;
+        }
+        // or throw
+        throw new errors_1.ArgumentError('Value is not a Language: ' + String(value));
+    }
+    Language.guard = guard;
+    function tryParse(value) {
+        // skip if there's no value
+        if (!value) {
+            return undefined;
+        }
+        // or try to parse it
+        const normalizedValue = value.trim().toLowerCase();
+        return filter(normalizedValue) ? normalizedValue : undefined;
+    }
+    Language.tryParse = tryParse;
+    function parse(value) {
+        // throw if the value can't be parsed
+        const language = tryParse(value);
+        if (!language) {
+            throw new errors_1.ArgumentError(`Invalid language: ${language}`, 'language');
+        }
+        // or return language
+        return language;
+    }
+    Language.parse = parse;
+})(Language || (exports.Language = Language = {}));

package/dist/regionalization/Locale.d.ts

@@ -0,0 +1,28 @@
+import { Language } from './Language';
+import { RegionsConfig } from '../app';
+export type Locale<TRegion extends string = string> = {
+    region: TRegion;
+    language: Language;
+};
+export declare namespace Locale {
+    type Data = `${string}-${Language}`;
+    type Params<TRegion extends string = string> = {
+        region: TRegion;
+        language: Language;
+    };
+    type RegionParam<TRegion extends string = string> = {
+        region: TRegion;
+    };
+    type LanguageParam = {
+        language: Language;
+    };
+    type GetRegionArgs = {
+        locale: Locale;
+        config: RegionsConfig;
+    };
+    function filter(value: string): value is Data;
+    function tryParse<TRegion extends string = string>(value: string): Locale<TRegion> | undefined;
+    function parse<TRegion extends string = string>(value: string): Locale<TRegion>;
+    function toData(locale: Locale): Data;
+    function isEqual(from: Partial<Locale>, to: Partial<Locale>): boolean;
+}

package/dist/regionalization/Locale.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Locale = void 0;
+const errors_1 = require("../errors");
+const Language_1 = require("./Language");
+// extension
+var Locale;
+(function (Locale) {
+    // helpers
+    function filter(value) {
+        const components = value.trim().split('-');
+        return components.length === 2
+            && components[0].length > 0
+            && Language_1.Language.filter(components[1]);
+    }
+    Locale.filter = filter;
+    function tryParse(value) {
+        // fail if there aren't exactly 2 components
+        const components = value.trim().split('-');
+        if (components.length !== 2) {
+            return undefined;
+        }
+        // fail if region or language don't fit
+        const region = components[0].trim().length > 0 ? components[0] : undefined;
+        const language = Language_1.Language.tryParse(components[1]);
+        return region && language
+            ? { region, language }
+            : undefined;
+    }
+    Locale.tryParse = tryParse;
+    function parse(value) {
+        // parse (or throw)
+        const locale = tryParse(value);
+        if (!locale) {
+            throw new errors_1.ArgumentError(`Invalid locale: ${value}`, 'locale');
+        }
+        // return locale
+        return locale;
+    }
+    Locale.parse = parse;
+    function toData(locale) {
+        return `${locale.region}-${locale.language}`;
+    }
+    Locale.toData = toData;
+    function isEqual(from, to) {
+        return from.region === to.region && from.language === to.language;
+    }
+    Locale.isEqual = isEqual;
+})(Locale || (exports.Locale = Locale = {}));

package/dist/regionalization/Localized.d.ts

@@ -0,0 +1,10 @@
+import { Language } from './Language';
+export type Localized<T> = Partial<Record<Language, T>>;
+export declare namespace Localized {
+    type Maybe<T> = T | Localized<T>;
+    namespace Maybe {
+        function tryGet<T>(localized: Maybe<T>, language: Language): T | undefined;
+        function get<T>(localized: Maybe<T>, language: Language): T;
+    }
+    function filter<T>(value: any): value is Localized<T>;
+}

package/dist/regionalization/Localized.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Localized = void 0;
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+const Language_1 = require("./Language");
+// extension
+var Localized;
+(function (Localized) {
+    let Maybe;
+    (function (Maybe) {
+        // helper
+        function tryGet(localized, language) {
+            return filter(localized)
+                ? localized[language]
+                : localized;
+        }
+        Maybe.tryGet = tryGet;
+        function get(localized, language) {
+            // get value (throw if it's not defined)
+            const value = tryGet(localized, language);
+            if (!value) {
+                throw new errors_1.ArgumentError(`No language mapped for language "${language}"`);
+            }
+            // return value
+            return value;
+        }
+        Maybe.get = get;
+    })(Maybe = Localized.Maybe || (Localized.Maybe = {}));
+    // guard
+    function filter(value) {
+        return utils_1.Value.isObject(value)
+            && Object.keys(value).every(Language_1.Language.filter);
+    }
+    Localized.filter = filter;
+})(Localized || (exports.Localized = Localized = {}));

package/dist/regionalization/LocalizedCopy.d.ts

@@ -0,0 +1,9 @@
+import { Localized } from './Localized';
+import { Language } from './Language';
+export declare class LocalizedCopy<T> {
+    readonly translations: Readonly<Localized<T>>;
+    constructor(translations: Readonly<Localized<T>>);
+    hasCopy(language: Language): boolean;
+    private tryGetCopy;
+    getCopy(language: Language): T;
+}

package/dist/regionalization/LocalizedCopy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizedCopy = void 0;
+const errors_1 = require("../errors");
+// class
+class LocalizedCopy {
+    constructor(translations) {
+        this.translations = translations;
+    }
+    hasCopy(language) {
+        return !!this.translations[language];
+    }
+    tryGetCopy(language) {
+        return this.translations[language];
+    }
+    getCopy(language) {
+        const copy = this.tryGetCopy(language);
+        // throw if there's no copy
+        if (!copy) {
+            throw new errors_1.ArgumentError(`No copy files configured for language: ${language}`);
+        }
+        // or return copy
+        return copy;
+    }
+}
+exports.LocalizedCopy = LocalizedCopy;

package/dist/regionalization/Regionalization.d.ts

@@ -0,0 +1,50 @@
+import { RegionsConfig } from '../app';
+import { Locale } from './Locale';
+export declare namespace Regionalization {
+    type ParsedBrowserUrl = {
+        sourceLocale: Partial<Locale>;
+        serverLocale: Locale;
+        pagePath: string;
+    };
+    /**
+     * A function that parses out the locale used within the server, a partial locale hat was provide by the user through the URL, and the non-regional path.
+     *
+     * @param source source URL or path
+     * @param regionalization regions config that determines our server locale
+     * @param userLocale a optional locale that is used to infer any missing region/locale in the returned server locale.
+     */
+    function parseBrowserUrl(source: URL | string, regionalization: RegionsConfig, userLocale: Locale): ParsedBrowserUrl;
+    type TargetUrl = {
+        targetLocale: Partial<Locale>;
+        targetUrl: URL;
+    };
+    /**
+     * A function that gets the URL and Locale visible to a  browser, based on the UrlTruncation in the RegionsConfig.
+     * @param sourceLocale
+     * @param pagePath
+     * @param regionalization
+     * @param sourceUrl
+     * @private
+     */
+    function targetUrlFor(sourceLocale: Locale, pagePath: string, regionalization: RegionsConfig, sourceUrl: URL): TargetUrl;
+    type TargetPathWithLocale = {
+        targetLocale: Partial<Locale>;
+        targetPath: string;
+    };
+    type GetTargetPathArgs = {
+        sourceLocale: Locale;
+        pagePath: string;
+        regionalization: RegionsConfig;
+    };
+    function getTargetPath({ sourceLocale, pagePath, regionalization }: GetTargetPathArgs): TargetPathWithLocale;
+    function mergedPathFor(locale: Partial<Locale>, path: string): string;
+    function splitPathFor(locale: Partial<Locale>, path: string): string;
+    /**
+     * A function that returns the intended URL for the server given a full locale and a non-regional path.
+     *
+     * @param locale
+     * @param path
+     * @param baseUrl
+     */
+    function serverUrlFor(locale: Locale, path: string, baseUrl: URL): URL;
+}