@nascentdigital/funnel-core 4.4.4

package/dist/schema/Page.js

@@ -0,0 +1,244 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+// class
+class Page {
+    // constructor
+    constructor(args) {
+        var _a, _b;
+        // initialize common instance variables
+        this.variant = args.variant;
+        this.route = args.route;
+        this.tags = (_a = args.tags) !== null && _a !== void 0 ? _a : [];
+        this.name = args.name;
+        this.description = args.description;
+        this.displayName = args.displayName;
+        this.optional = (_b = args.optional) !== null && _b !== void 0 ? _b : false;
+        this.preview = args.preview;
+        this.content = args.content;
+        // or dynamic args (basic)
+        if (Page.ConstructorArgs.Dynamic.filter(args)) {
+            this.parent = args.parent;
+        }
+    }
+    get type() {
+        // throw if not bound
+        const { _type } = this;
+        if (!_type) {
+            throw new errors_1.InvalidOperationError('Attempt to access "type" before call to Page.bind()');
+        }
+        // return id
+        return _type;
+    }
+    bind(type) {
+        // ignore if the type is the same
+        if (this._type === type) {
+            return;
+        }
+        // throw if already bound
+        if (this._type) {
+            throw new errors_1.InvalidOperationError('Cannot bind() Page more than once');
+        }
+        // bind it
+        this._type = type;
+    }
+    static static(_a) {
+        var { route } = _a, args = __rest(_a, ["route"]);
+        return new Page(Object.assign({ variant: 'static', route: route }, args));
+    }
+    static dynamic(args) {
+        return new Page({
+            variant: 'dynamic',
+            route: args.route,
+            tags: args.tags,
+            name: args.name,
+            preview: args.preview,
+            content: args.content,
+            displayName: args.displayName,
+            parent: args.parent,
+        });
+    }
+}
+exports.Page = Page;
+// extension
+(function (Page) {
+    let Data;
+    (function (Data) {
+        // props (used to reduce risk of losing data across platform)
+        let Props;
+        (function (Props) {
+            Props.id = ['id', 'groupId', 'brand', 'type', 'tags', 'region', 'language', 'slug', 'url', 'name'];
+            Props.content = ['discover', 'preview', 'content'];
+            Props.links = ['files', 'pages', 'collections'];
+            Props.audit = ['state', 'errors', 'changeSetId', 'snapshotId', 'createdOn', 'updatedOn', 'publishedOn', 'publication'];
+            Props.backup = ['snapshot'];
+            Props.all = [
+                ...Props.id,
+                ...Props.content,
+                ...Props.links,
+                ...Props.audit,
+                ...Props.backup
+            ];
+        })(Props = Data.Props || (Data.Props = {}));
+        let AsDraft;
+        (function (AsDraft) {
+            AsDraft.props = [
+                ...Props.id.filter(prop => prop !== 'id'),
+                'changeSetId'
+            ];
+        })(AsDraft = Data.AsDraft || (Data.AsDraft = {}));
+        let AsNew;
+        (function (AsNew) {
+            AsNew.props = [
+                ...Props.id.filter(prop => prop !== 'id' && prop !== 'groupId' && prop !== 'url'),
+                'changeSetId'
+            ];
+        })(AsNew = Data.AsNew || (Data.AsNew = {}));
+        let AsNewLanguage;
+        (function (AsNewLanguage) {
+            AsNewLanguage.props = ['brand', 'groupId', 'slug', 'language'];
+            // type guard
+            function filter(page) {
+                return 'groupId' in page;
+            }
+            AsNewLanguage.filter = filter;
+        })(AsNewLanguage = Data.AsNewLanguage || (Data.AsNewLanguage = {}));
+        let AsRef;
+        (function (AsRef) {
+            AsRef.props = ['id', 'url'];
+        })(AsRef = Data.AsRef || (Data.AsRef = {}));
+        let AsLink;
+        (function (AsLink) {
+            AsLink.props = [...Props.id, ...Props.audit];
+            function from(data) {
+                const { splitProps: asLink } = utils_1.ObjectUtils.splitProps(data, AsLink.props);
+                return asLink;
+            }
+            AsLink.from = from;
+        })(AsLink = Data.AsLink || (Data.AsLink = {}));
+        let AsPreview;
+        (function (AsPreview) {
+            AsPreview.props = [
+                ...Props.id,
+                'preview',
+                ...Props.links,
+                ...Props.audit
+            ];
+            function from(data) {
+                const { splitProps: asPreview } = utils_1.ObjectUtils.splitProps(data, AsPreview.props);
+                return asPreview;
+            }
+            AsPreview.from = from;
+            function filter(data) {
+                return !('content' in data);
+            }
+            AsPreview.filter = filter;
+        })(AsPreview = Data.AsPreview || (Data.AsPreview = {}));
+        let AsGroup;
+        (function (AsGroup) {
+            let Instance;
+            (function (Instance) {
+                Instance.props = [
+                    'id', 'name', 'language', 'url', 'slug', 'tags',
+                    ...Props.audit.filter(prop => prop !== 'publication')
+                ];
+            })(Instance = AsGroup.Instance || (AsGroup.Instance = {}));
+        })(AsGroup = Data.AsGroup || (Data.AsGroup = {}));
+        // guard
+        function filter(value) {
+            return utils_1.Value.typeOf(value) === 'object'
+                && '__root' in value
+                && value.__root === 'page';
+        }
+        Data.filter = filter;
+    })(Data = Page.Data || (Page.Data = {}));
+    let LinkedData;
+    (function (LinkedData) {
+        let AsLink;
+        (function (AsLink) {
+            function from(data) {
+                const { splitProps: asLink } = utils_1.ObjectUtils.splitProps(data, Data.AsLink.props);
+                return asLink;
+            }
+            AsLink.from = from;
+        })(AsLink = LinkedData.AsLink || (LinkedData.AsLink = {}));
+        let AsPreview;
+        (function (AsPreview) {
+            function from(data) {
+                const { splitProps: asPreview } = utils_1.ObjectUtils.splitProps(data, Data.AsPreview.props);
+                return asPreview;
+            }
+            AsPreview.from = from;
+        })(AsPreview = LinkedData.AsPreview || (LinkedData.AsPreview = {}));
+    })(LinkedData = Page.LinkedData || (Page.LinkedData = {}));
+    let Id;
+    (function (Id) {
+        Id.draft = '__draft.id__';
+    })(Id = Page.Id || (Page.Id = {}));
+    let Type;
+    (function (Type) {
+        Type.unknown = '__unknown.type__';
+    })(Type = Page.Type || (Page.Type = {}));
+    let GroupId;
+    (function (GroupId) {
+        GroupId.empty = '__draft.group__';
+    })(GroupId = Page.GroupId || (Page.GroupId = {}));
+    let State;
+    (function (State) {
+        State.values = ['published', 'draft', 'unpublished'];
+        function coerce(value) {
+            // return published if there's no value
+            const normalizedValue = (value !== null && value !== void 0 ? value : '').trim().toLowerCase();
+            if (!normalizedValue) {
+                return 'published';
+            }
+            // or return value if it's a match
+            else if (State.values.includes(normalizedValue)) {
+                return normalizedValue;
+            }
+            // otherwise throw
+            else {
+                throw new errors_1.ArgumentError(`Unrecognized Page.State value "${value}"`);
+            }
+        }
+        State.coerce = coerce;
+        function coerceLive(value) {
+            const state = coerce(value);
+            if (state === 'unpublished') {
+                throw new errors_1.ArgumentError(`The "unpublished" Page.State isn't allowed`);
+            }
+            return state;
+        }
+        State.coerceLive = coerceLive;
+    })(State = Page.State || (Page.State = {}));
+    let ConstructorArgs;
+    (function (ConstructorArgs) {
+        let Static;
+        (function (Static) {
+            function filter(args) {
+                return args.variant === 'static';
+            }
+            Static.filter = filter;
+        })(Static = ConstructorArgs.Static || (ConstructorArgs.Static = {}));
+        let Dynamic;
+        (function (Dynamic) {
+            function filter(args) {
+                return args.variant === 'dynamic';
+            }
+            Dynamic.filter = filter;
+        })(Dynamic = ConstructorArgs.Dynamic || (ConstructorArgs.Dynamic = {}));
+    })(ConstructorArgs = Page.ConstructorArgs || (Page.ConstructorArgs = {}));
+})(Page || (exports.Page = Page = {}));

package/dist/schema/PageModel.d.ts

@@ -0,0 +1,58 @@
+import { Page } from './Page';
+import { PageRoute } from './PageRoute';
+import { Seo } from './Seo';
+export declare class PageModel<TPage extends Page = Page> {
+    readonly data: Page.Data<TPage>;
+    constructor(data: Page.Data<TPage>);
+    get schema(): Page;
+    get seo(): Seo.Data;
+    /**
+     * Synchronizes computed properties with the latest `PageModel` data (e.g. updating `url` from route template or name)
+     */
+    sync(): void;
+    /**
+     * Applies updates *in place* to the underlying `Page.Data`.
+     *
+     * @param updates - a collection of updates to be applied to this page.
+     */
+    update(updates: ReadonlyArray<Page.Update>): void;
+    private updateTags;
+    private updateBlockCreate;
+    private updateBlockDelete;
+    private updateSectionInsert;
+    private updateSectionDelete;
+    private updateSectionReorder;
+    private updateSectionBlockName;
+    private updateObjectInsert;
+    private updateArrayInsert;
+    private updateArrayDelete;
+    private updateArrayReorder;
+    private updateValue;
+    private setValue;
+    private findValue;
+    private find;
+    private findInSection;
+    private findInBlock;
+    private findInValue;
+    private computeUrl;
+    private computeName;
+    private computePreview;
+    static from<TPage extends Page = Page>(data: Page.Data<TPage>): PageModel<TPage>;
+    static fromDraft<TPage extends Page = Page>(data: Page.Data.AsDraft<TPage>): PageModel<TPage>;
+}
+export declare namespace PageModel {
+    type SyncArgs = {
+        route: PageRoute;
+    };
+    type TargetArea = Extract<keyof Page.Data, 'discover' | 'preview' | 'content'>;
+    namespace TargetArea {
+        type Root = Page.Data.Content<any>;
+        type Extraction = {
+            area: TargetArea;
+            path: string[];
+        };
+        function extract([area, ...path]: string[]): Extraction;
+        function filter(key: string | undefined): key is TargetArea;
+    }
+    type TargetPath = `${Page.Data.Props.All}` | `${Page.Data.Props.All}.${string}` | `${Page.Data.Props.All}.${string}.${string}` | `${Page.Data.Props.All}.${string}.${string}.${string}`;
+}