@nascentdigital/funnel-core 4.4.4

package/dist/regionalization/Regionalization.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Regionalization = void 0;
+const app_1 = require("../app");
+const Language_1 = require("./Language");
+var Regionalization;
+(function (Regionalization) {
+    /**
+     * 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, regionalization, userLocale) {
+        var _a, _b;
+        // get Regionalization Type so we can properly assess source locale
+        const regionalizationType = app_1.RegionsConfig.getType(regionalization);
+        // set up
+        const sourceLocale = {};
+        let potentialRegion;
+        let potentialLanguage;
+        let pagePathComponents = [];
+        const sourcePath = typeof source === 'string'
+            ? source
+            : source.pathname;
+        // page path components that were initially removed that we want to add back
+        const addBacks = [''];
+        // determine potential source locale
+        switch (regionalizationType) {
+            case 'language-only': {
+                // don't support having regions in our paths
+                const [, language, ...pagePath] = sourcePath.split('/');
+                potentialLanguage = language;
+                // build the page path components without the potential language
+                pagePathComponents = pagePath;
+                break;
+            }
+            case 'region-only': {
+                // dont support languages in path
+                const [, region, ...pagePath] = sourcePath.split('/');
+                potentialRegion = region;
+                // build the page path components without the potential region
+                pagePathComponents = pagePath;
+                break;
+            }
+            case 'locale-composite': {
+                // could have both language and region in path
+                const [, rawLocale, ...pagePath] = sourcePath.split('/');
+                const [region, language] = rawLocale.split('-');
+                potentialRegion = region;
+                potentialLanguage = language;
+                // build the page path components without the potential language and region
+                pagePathComponents = pagePath;
+                break;
+            }
+            case 'locale-split': {
+                // could have both language and region in path
+                const [, region, language, ...pagePath] = sourcePath.split('/');
+                potentialRegion = region;
+                potentialLanguage = language;
+                // build the page path components without the potential language and region
+                pagePathComponents = pagePath;
+                break;
+            }
+        }
+        // validate potential source region
+        const sourceRegion = app_1.RegionsConfig.tryParse(regionalization, potentialRegion);
+        if (sourceRegion) {
+            // assign it to source locale
+            sourceLocale.region = sourceRegion;
+        }
+        // otherwise add it to the list of 'addBacks' that will be later added back to 'pagePathComponents'
+        else if (potentialRegion) {
+            addBacks.push(potentialRegion);
+        }
+        // validate potential source language
+        const sourceLanguage = Language_1.Language.tryParse(potentialLanguage);
+        if (sourceLanguage) {
+            // assign it to source locale
+            sourceLocale.language = sourceLanguage;
+        }
+        // otherwise add it to the list of 'addBacks' that will be later added back to 'pagePathComponents'
+        else if (potentialLanguage) {
+            addBacks.push(potentialLanguage);
+        }
+        // determine the server region
+        const serverRegion = (_a = sourceLocale.region) !== null && _a !== void 0 ? _a : userLocale.region;
+        const regionConfig = app_1.RegionsConfig.getRegionConfig(regionalization, serverRegion);
+        // if source language is part of server region then use it, otherwise if user language is part of server region then use it, otherwise fall back to server region's default language
+        const serverLanguage = sourceLocale.language && regionConfig.languages.includes(sourceLocale.language)
+            ? sourceLocale.language
+            : regionConfig.languages.includes(userLocale.language)
+                ? userLocale.language
+                : (_b = regionConfig.defaultLanguage) !== null && _b !== void 0 ? _b : regionConfig.languages[0];
+        // return
+        return {
+            sourceLocale,
+            serverLocale: {
+                region: serverRegion,
+                language: serverLanguage
+            },
+            // if both the potential region and language were not valid, fall back to the original path otherwise use the add backs to get the page path
+            pagePath: addBacks.length === 3
+                ? sourcePath
+                : addBacks.concat(pagePathComponents).join('/')
+        };
+    }
+    Regionalization.parseBrowserUrl = parseBrowserUrl;
+    /**
+     * 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, pagePath, regionalization, sourceUrl) {
+        // determine the target path/locale
+        const { targetLocale, targetPath } = getTargetPath({ sourceLocale, pagePath, regionalization });
+        // create a URL from the path (preserves query params, etc.)
+        const targetUrl = new URL(sourceUrl);
+        targetUrl.pathname = targetPath;
+        // return result
+        return { targetLocale, targetUrl };
+    }
+    Regionalization.targetUrlFor = targetUrlFor;
+    function getTargetPath({ sourceLocale, pagePath, regionalization }) {
+        // get target locale based on url truncation
+        const targetLocale = {};
+        switch (regionalization.urlTruncation) {
+            case 'none': {
+                // Always return region and language
+                targetLocale.region = sourceLocale.region;
+                targetLocale.language = sourceLocale.language;
+                break;
+            }
+            case 'partial':
+                {
+                    // if both region and language are default omit them both
+                    if (sourceLocale.region === regionalization.fallback && app_1.RegionsConfig.getDefaultLanguageForRegion(regionalization.regions[regionalization.fallback], {}) === sourceLocale.language) {
+                        // do nothing
+                    }
+                    // if region is default region but language is not default, show language and region
+                    else if (sourceLocale.region === regionalization.fallback && app_1.RegionsConfig.getDefaultLanguageForRegion(regionalization.regions[regionalization.fallback], {}) !== sourceLocale.language) {
+                        targetLocale.region = sourceLocale.region;
+                        targetLocale.language = sourceLocale.language;
+                    }
+                    // if for given region, the language is default, omit the language
+                    else if (app_1.RegionsConfig.getDefaultLanguageForRegion(regionalization.regions[sourceLocale.region], {}) === sourceLocale.language) {
+                        targetLocale.region = sourceLocale.region;
+                    }
+                    // otherwise include both of them
+                    else {
+                        targetLocale.region = sourceLocale.region;
+                        targetLocale.language = sourceLocale.language;
+                    }
+                    break;
+                }
+            case 'full':
+                {
+                    // omit region and language if both are default
+                    if (regionalization.fallback === sourceLocale.region && app_1.RegionsConfig.getDefaultLanguage(regionalization, {}) === sourceLocale.language) {
+                        // do nothing
+                    }
+                    // otherwise include both of them
+                    else {
+                        targetLocale.region = sourceLocale.region;
+                        targetLocale.language = sourceLocale.language;
+                    }
+                    break;
+                }
+        }
+        // clear any values based on type
+        const regionType = app_1.RegionsConfig.getType(regionalization);
+        switch (regionType) {
+            case 'language-only':
+                targetLocale.region = undefined;
+                // if there is only a single language, also hide the language
+                if (app_1.RegionsConfig.getLanguages(regionalization).length === 1) {
+                    targetLocale.language = undefined;
+                }
+                break;
+            case 'region-only':
+                targetLocale.language = undefined;
+                break;
+        }
+        // if merged routes and both region and language exist append with '-'
+        let targetPath;
+        if (regionalization.mergedRoutes && targetLocale.region && targetLocale.language) {
+            targetPath = `/${targetLocale.region}-${targetLocale.language}`;
+        }
+        // or build segments based on region/language existing in target
+        else {
+            // start with nothing
+            targetPath = '';
+            // add region, if we have one
+            if (targetLocale.region) {
+                targetPath += `/${targetLocale.region}`;
+            }
+            // add language if we have one
+            if (targetLocale.language) {
+                targetPath += `/${targetLocale.language}`;
+            }
+        }
+        // add page path
+        const normalizedPagePath = pagePath.startsWith('/')
+            ? pagePath
+            : `/${pagePath}`;
+        if (normalizedPagePath.length > 1) {
+            targetPath += normalizedPagePath;
+        }
+        // return result
+        return { targetLocale, targetPath };
+    }
+    Regionalization.getTargetPath = getTargetPath;
+    function mergedPathFor(locale, path) {
+        // if both region/lang concatenate with -
+        if (locale.region && locale.language) {
+            return `/${locale.region}-${locale.language}${path}`;
+        }
+        // if only region omit lang and concatenation
+        else if (locale.region) {
+            return `/${locale.region}${path}`;
+        }
+        // if only lang omit region and concatenation
+        else if (locale.language) {
+            return `/${locale.language}${path}`;
+        }
+        return path;
+    }
+    Regionalization.mergedPathFor = mergedPathFor;
+    function splitPathFor(locale, path) {
+        // if both region/lang concatenate with -
+        if (locale.region && locale.language) {
+            return `/${locale.region}/${locale.language}${path}`;
+        }
+        // if only region omit lang and concatenation
+        else if (locale.region) {
+            return `/${locale.region}${path}`;
+        }
+        // if only lang omit region and concatenation
+        else if (locale.language) {
+            return `/${locale.language}${path}`;
+        }
+        return path;
+    }
+    Regionalization.splitPathFor = splitPathFor;
+    /**
+     * 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, path, baseUrl) {
+        return new URL(splitPathFor(locale, path), baseUrl);
+    }
+    Regionalization.serverUrlFor = serverUrlFor;
+})(Regionalization || (exports.Regionalization = Regionalization = {}));

package/dist/regionalization/Regions.d.ts

@@ -0,0 +1,2 @@
+import { Language } from './Language';
+export type Regions = Record<string, Language[]>;

package/dist/regionalization/Regions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/regionalization/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Language';
+export * from './Localized';
+export * from './LocalizedCopy';
+export * from './Country';
+export * from './Locale';
+export * from './Regionalization';
+export * from './Regions';

package/dist/regionalization/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Language"), exports);
+__exportStar(require("./Localized"), exports);
+__exportStar(require("./LocalizedCopy"), exports);
+__exportStar(require("./Country"), exports);
+__exportStar(require("./Locale"), exports);
+__exportStar(require("./Regionalization"), exports);
+__exportStar(require("./Regions"), exports);

package/dist/schema/Asset.d.ts

@@ -0,0 +1,23 @@
+import { Tagged } from 'type-fest';
+import { AssetField, Field } from './field';
+export type Asset<TValue extends AssetField.LinkedValue = AssetField.LinkedValue> = Field.Data<AssetField<TValue>>;
+export declare namespace Asset {
+    type Id = Tagged<string, 'Asset.Id'>;
+    type Image = Asset<AssetField.LinkedValue.Image>;
+    type Video = Asset<AssetField.LinkedValue.Video>;
+    type Audio = Asset<AssetField.LinkedValue.Audio>;
+    type Document = Asset<AssetField.LinkedValue.Document>;
+    function filter(value: any): value is Asset;
+    function getId(asset: Asset | Asset.Linked): Id;
+    type Linked<TValue extends AssetField.LinkedValue = AssetField.LinkedValue> = Field.LinkedData<AssetField<TValue>> & {
+        __root: 'asset';
+    };
+    namespace Linked {
+        type Visual = Linked<AssetField.LinkedValue.Image | AssetField.LinkedValue.Video>;
+        type Image = Linked<AssetField.LinkedValue.Image>;
+        type Video = Linked<AssetField.LinkedValue.Video>;
+        type Audio = Linked<AssetField.LinkedValue.Audio>;
+        type Document = Linked<AssetField.LinkedValue.Document>;
+        function filter(value: any): value is Linked;
+    }
+}

package/dist/schema/Asset.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Asset = void 0;
+const utils_1 = require("../utils");
+const field_1 = require("./field");
+var Asset;
+(function (Asset) {
+    // guard
+    function filter(value) {
+        return !!value
+            && utils_1.Value.typeOf(value) === 'object'
+            && value.type === 'asset'
+            && '__ref' in value
+            && value.__ref === 'asset'
+            && 'value' in value
+            && field_1.AssetField.Value.filter(value.value);
+    }
+    Asset.filter = filter;
+    // helpers
+    function getId(asset) {
+        return asset.value.id;
+    }
+    Asset.getId = getId;
+    let Linked;
+    (function (Linked) {
+        // guard
+        function filter(value) {
+            return !!value
+                && utils_1.Value.typeOf(value) === 'object'
+                && value.type === 'asset'
+                && '__root' in value
+                && value.__root === 'asset';
+        }
+        Linked.filter = filter;
+    })(Linked = Asset.Linked || (Asset.Linked = {}));
+})(Asset || (exports.Asset = Asset = {}));

package/dist/schema/AssetScope.d.ts

@@ -0,0 +1,75 @@
+import { Collection as CollectionType } from './Collection';
+import { Page as PageType } from './Page';
+export declare abstract class AbstractAssetScope {
+    abstract get data(): AssetScope.Data;
+}
+export declare class GlobalAssetScope extends AbstractAssetScope {
+    static readonly instance: GlobalAssetScope;
+    readonly range: AssetScope.Range;
+    private constructor();
+    get data(): AssetScope.Data.Global;
+}
+export declare abstract class TypeAssetScope extends AbstractAssetScope {
+    readonly range: AssetScope.Range;
+}
+export declare class PageTypeAssetScope extends TypeAssetScope {
+    readonly type: PageType.Type;
+    readonly target: AssetScope.Target;
+    constructor(type: PageType.Type);
+    get data(): AssetScope.Data.Type.Page;
+}
+export declare class CollectionTypeAssetScope extends TypeAssetScope {
+    readonly type: CollectionType.Type;
+    readonly target: AssetScope.Target;
+    constructor(type: CollectionType.Type);
+    get data(): AssetScope.Data.Type.Collection;
+}
+export declare abstract class InstanceAssetScope extends AbstractAssetScope {
+    readonly range: AssetScope.Range;
+}
+export declare class PageInstanceAssetScope extends InstanceAssetScope {
+    readonly groupId: PageType.GroupId;
+    readonly target: AssetScope.Target;
+    constructor(groupId: PageType.GroupId);
+    get data(): AssetScope.Data.Instance.Page;
+}
+export declare class CollectionInstanceAssetScope extends InstanceAssetScope {
+    readonly groupId: CollectionType.GroupId;
+    readonly target: AssetScope.Target;
+    constructor(groupId: CollectionType.GroupId);
+    get data(): AssetScope.Data.Instance.Collection;
+}
+export type AssetScope = GlobalAssetScope | PageTypeAssetScope | CollectionTypeAssetScope | PageInstanceAssetScope | CollectionInstanceAssetScope;
+export declare namespace AssetScope {
+    const global: GlobalAssetScope;
+    type Range = 'global' | 'type' | 'instance';
+    type Target = 'page' | 'collection';
+    type Data = Data.Global | Data.Type | Data.Instance;
+    namespace Data {
+        const PagePrefix = "page/";
+        type PagePrefix = typeof PagePrefix;
+        const CollectionPrefix = "collection/";
+        type CollectionPrefix = typeof CollectionPrefix;
+        const TypePrefix = "type/";
+        type TypePrefix = typeof TypePrefix;
+        const InstancePrefix = "instance/";
+        type InstancePrefix = typeof InstancePrefix;
+        const global = "global";
+        type Global = typeof global;
+        type Type = Type.Page | Type.Collection;
+        namespace Type {
+            type Page = `${TypePrefix}${PagePrefix}${PageType.Type}`;
+            type Collection = `${TypePrefix}${CollectionPrefix}${CollectionType.Type}`;
+            function forPage(type: PageType.Type): Page;
+            function forCollection(type: CollectionType.Type): Collection;
+        }
+        type Instance = Instance.Page | Instance.Collection;
+        namespace Instance {
+            type Page = `${InstancePrefix}${PagePrefix}${PageType.GroupId}`;
+            type Collection = `${InstancePrefix}${CollectionPrefix}${CollectionType.GroupId}`;
+            function forPage(groupId: PageType.GroupId): Page;
+            function forCollection(groupId: CollectionType.GroupId): Collection;
+        }
+    }
+    function fromData(data: string): AssetScope | undefined;
+}

package/dist/schema/AssetScope.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetScope = exports.CollectionInstanceAssetScope = exports.PageInstanceAssetScope = exports.InstanceAssetScope = exports.CollectionTypeAssetScope = exports.PageTypeAssetScope = exports.TypeAssetScope = exports.GlobalAssetScope = exports.AbstractAssetScope = void 0;
+// classes
+class AbstractAssetScope {
+}
+exports.AbstractAssetScope = AbstractAssetScope;
+// global-scoped
+class GlobalAssetScope extends AbstractAssetScope {
+    constructor() {
+        super();
+        this.range = 'global';
+    }
+    get data() {
+        return 'global';
+    }
+}
+exports.GlobalAssetScope = GlobalAssetScope;
+GlobalAssetScope.instance = new GlobalAssetScope();
+// type-scoped
+class TypeAssetScope extends AbstractAssetScope {
+    constructor() {
+        super(...arguments);
+        this.range = 'type';
+    }
+}
+exports.TypeAssetScope = TypeAssetScope;
+class PageTypeAssetScope extends TypeAssetScope {
+    constructor(type) {
+        super();
+        this.type = type;
+        this.target = 'page';
+    }
+    get data() {
+        return `${AssetScope.Data.TypePrefix}${AssetScope.Data.PagePrefix}${this.type}`;
+    }
+}
+exports.PageTypeAssetScope = PageTypeAssetScope;
+class CollectionTypeAssetScope extends TypeAssetScope {
+    constructor(type) {
+        super();
+        this.type = type;
+        this.target = 'collection';
+    }
+    get data() {
+        return `${AssetScope.Data.TypePrefix}${AssetScope.Data.CollectionPrefix}${this.type}`;
+    }
+}
+exports.CollectionTypeAssetScope = CollectionTypeAssetScope;
+// type-scoped
+class InstanceAssetScope extends AbstractAssetScope {
+    constructor() {
+        super(...arguments);
+        this.range = 'instance';
+    }
+}
+exports.InstanceAssetScope = InstanceAssetScope;
+class PageInstanceAssetScope extends InstanceAssetScope {
+    constructor(groupId) {
+        super();
+        this.groupId = groupId;
+        this.target = 'page';
+    }
+    get data() {
+        return `${AssetScope.Data.InstancePrefix}${AssetScope.Data.PagePrefix}${this.groupId}`;
+    }
+}
+exports.PageInstanceAssetScope = PageInstanceAssetScope;
+class CollectionInstanceAssetScope extends InstanceAssetScope {
+    constructor(groupId) {
+        super();
+        this.groupId = groupId;
+        this.target = 'collection';
+    }
+    get data() {
+        return `${AssetScope.Data.InstancePrefix}${AssetScope.Data.CollectionPrefix}${this.groupId}`;
+    }
+}
+exports.CollectionInstanceAssetScope = CollectionInstanceAssetScope;
+var AssetScope;
+(function (AssetScope) {
+    // constants
+    AssetScope.global = GlobalAssetScope.instance;
+    let Data;
+    (function (Data) {
+        // prefixes
+        Data.PagePrefix = 'page/';
+        Data.CollectionPrefix = 'collection/';
+        Data.TypePrefix = 'type/';
+        Data.InstancePrefix = 'instance/';
+        // global scoping
+        Data.global = 'global';
+        let Type;
+        (function (Type) {
+            function forPage(type) {
+                return `${Data.TypePrefix}${Data.PagePrefix}${type}`;
+            }
+            Type.forPage = forPage;
+            function forCollection(type) {
+                return `${Data.TypePrefix}${Data.CollectionPrefix}${type}`;
+            }
+            Type.forCollection = forCollection;
+        })(Type = Data.Type || (Data.Type = {}));
+        let Instance;
+        (function (Instance) {
+            function forPage(groupId) {
+                return `${Data.InstancePrefix}${Data.PagePrefix}${groupId}`;
+            }
+            Instance.forPage = forPage;
+            function forCollection(groupId) {
+                return `${Data.InstancePrefix}${Data.CollectionPrefix}${groupId}`;
+            }
+            Instance.forCollection = forCollection;
+        })(Instance = Data.Instance || (Data.Instance = {}));
+    })(Data = AssetScope.Data || (AssetScope.Data = {}));
+    // parsing
+    function fromData(data) {
+        // handle global scope
+        if (data === 'global') {
+            return AssetScope.global;
+        }
+        // or type scope
+        else if (data.startsWith(Data.TypePrefix)) {
+            const subvalue = data.substring(Data.TypePrefix.length);
+            if (subvalue.startsWith(Data.PagePrefix)) {
+                return new PageTypeAssetScope(subvalue.substring(Data.PagePrefix.length));
+            }
+            else if (subvalue.startsWith(Data.CollectionPrefix)) {
+                return new CollectionTypeAssetScope(subvalue.substring(Data.CollectionPrefix.length));
+            }
+        }
+        // or instance scope
+        else if (data.startsWith(Data.InstancePrefix)) {
+            const subvalue = data.substring(Data.InstancePrefix.length);
+            if (subvalue.startsWith(Data.PagePrefix)) {
+                return new PageInstanceAssetScope(subvalue.substring(Data.PagePrefix.length));
+            }
+            else if (subvalue.startsWith(Data.CollectionPrefix)) {
+                return new CollectionInstanceAssetScope(subvalue.substring(Data.CollectionPrefix.length));
+            }
+        }
+        // otherwise, it didn't parse
+        return undefined;
+    }
+    AssetScope.fromData = fromData;
+})(AssetScope || (exports.AssetScope = AssetScope = {}));