@nascentdigital/funnel-core 4.4.4

package/dist/schema/CollectionModel.js

@@ -0,0 +1,383 @@
+"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.CollectionModel = void 0;
+const errors_1 = require("../errors");
+const Collection_1 = require("./Collection");
+// class
+class CollectionModel {
+    constructor(data) {
+        this.data = data;
+    }
+    /**
+     * Synchronizes computed properties with the latest `CollectionModel` data (e.g. updating `name`)
+     */
+    sync() {
+        // TODO: add something when we need to sync
+    }
+    /**
+     * Applies updates *in place* to the underlying `Collection.Data`.
+     *
+     * @param updates - a collection of updates to be applied to this collection.
+     */
+    update(updates) {
+        // apply updates
+        updates.forEach(update => {
+            switch (update.type) {
+                case 'name':
+                    this.updateName(update);
+                    break;
+                case 'tags':
+                    this.updateTags(update);
+                    break;
+                case 'object.insert':
+                    this.updateObjectInsert(update);
+                    break;
+                case 'array.insert':
+                    this.updateArrayInsert(update);
+                    break;
+                case 'array.delete':
+                    this.updateArrayDelete(update);
+                    break;
+                case 'array.reorder':
+                    this.updateArrayReorder(update);
+                    break;
+                case 'value':
+                    this.updateValue(update);
+                    break;
+            }
+        });
+        // finally, sync the model
+        this.sync();
+    }
+    updateName(update) {
+        // replace name
+        const { data: collection } = this;
+        collection.name = update.name;
+    }
+    updateTags(update) {
+        // replace tags
+        const { data: collection } = this;
+        collection.tags = update.tags;
+    }
+    updateObjectInsert(_a) {
+        var { value } = _a, update = __rest(_a, ["value"]);
+        // resolve target (if required)
+        const { data: collection } = this;
+        const { root, path } = splitRoot(collection, update.path);
+        const [key] = path.splice(-1, 1);
+        const target = this.find(root, {
+            path,
+            parentPath: [],
+            issues: []
+        });
+        // fail if there's no target (shouldn't happen)
+        if (!target || typeof target !== 'object' || Array.isArray(target)) {
+            console.warn(`[CollectionModel/updateObjectInsert] could not find object parent at path "${path.join('.')}"`);
+        }
+        // fail if key is already set on parent
+        else if (key in target) {
+            console.warn(`[CollectionModel/updateObjectInsert] object already exists in "${target.type}" for key "${key}"`);
+        }
+        // or just add object
+        else {
+            console.debug(`[CollectionModel/updateObjectInsert] setting object at "${key}"`);
+            const parent = target;
+            parent[key] = value;
+        }
+    }
+    updateArrayInsert(_a) {
+        var { index, id, value } = _a, update = __rest(_a, ["index", "id", "value"]);
+        // resolve target
+        const { data: collection } = this;
+        const { root, path } = splitRoot(collection, update.path);
+        let target = this.find(root, {
+            path,
+            parentPath: [],
+            issues: []
+        });
+        // simply create the array if it doesn't exist
+        if (target === undefined || target === null) {
+            // resolve parent
+            const { parentPath, childKey } = splitPath(path);
+            target = this.find(root, {
+                path: parentPath,
+                parentPath: [],
+                issues: []
+            });
+            // fail if item's parent isn't found
+            if (!target) {
+                console.warn(`[CollectionModel/updateArrayInsert] could not find array parent at path "${path.join('.')}"`);
+            }
+            // or set value
+            else {
+                this.setValue(target, childKey, { type: 'list', value: [value] });
+            }
+        }
+        // or fail if target isn't an array
+        else if (target.type !== 'list') {
+            console.warn(`[CollectionModel/updateArrayInsert] could not find array at path "${path.join('.')}"`);
+        }
+        // or fail if item is already in list
+        else if (target.value.some(item => item.id === id)) {
+            console.warn(`[CollectionModel/updateArrayInsert] item is already in list at "${path.join('.')}" - ignoring`);
+        }
+        // or insert at end if index is out-of-bounds
+        else if (index < 0 || target.value.length < index) {
+            console.debug(`[CollectionModel/updateArrayInsert] item "${id}" index "${index}" is out of bounds (0, ${target.value.length} at "${path.join('.')}" - adding to end:`, value);
+            target.value.push(value);
+        }
+        // or insert item at index
+        else {
+            console.debug(`[CollectionModel/updateArrayInsert] inserting item "${id}" to "${index}" in list at "${path.join('.')}":`, value);
+            target.value.splice(index, 0, value);
+        }
+    }
+    updateArrayDelete(_a) {
+        var { id } = _a, update = __rest(_a, ["id"]);
+        // resolve target
+        const { data: collection } = this;
+        const { root, path } = splitRoot(collection, update.path);
+        const target = this.find(root, {
+            path,
+            parentPath: [],
+            issues: []
+        });
+        // skip if target isn't an array
+        if ((target === null || target === void 0 ? void 0 : target.type) !== 'list') {
+            console.warn(`[CollectionModel/updateArrayDelete] could not find array at path "${path.join('.')}"`);
+        }
+        // or remove target
+        else {
+            // find target index (fail if it's not there)
+            const list = target.value;
+            const index = list.findIndex(item => item.id === id);
+            if (index < 0) {
+                console.warn(`[CollectionModel/updateArrayDelete] no item with ID "${id}" in list at "${path.join('.')}"`);
+            }
+            // or splice it out
+            else {
+                console.warn(`[CollectionModel/updateArrayDelete] removed item "${id}" from list at "${path.join('.')}"`);
+                list.splice(index, 1);
+            }
+        }
+    }
+    updateArrayReorder(_a) {
+        var { ids } = _a, update = __rest(_a, ["ids"]);
+        // resolve target
+        const { data: collection } = this;
+        const { root, path } = splitRoot(collection, update.path);
+        const target = this.find(root, {
+            path,
+            parentPath: [],
+            issues: []
+        });
+        // fail if target isn't an array
+        if ((target === null || target === void 0 ? void 0 : target.type) !== 'list') {
+            console.warn(`[CollectionModel/updateArrayReorder] could not find array at path "${path.join('.')}"`);
+            return;
+        }
+        // create new array with the correct order - this drops item's that aren't in the intersection
+        const updatedValue = [];
+        ids.forEach(id => {
+            // add item if it's in the original
+            const item = target.value.find(item => item.id === id);
+            if (item) {
+                updatedValue.push(item);
+            }
+        });
+        // replace the value
+        target.value = updatedValue;
+    }
+    updateValue(_a) {
+        var { value } = _a, update = __rest(_a, ["value"]);
+        console.debug(`[CollectionModel/updateValue] executing value update`, { update, value });
+        // insert field if it's new
+        const { data: collection } = this;
+        const { root, path } = splitRoot(collection, update.path);
+        const { parentPath, childKey } = splitPath(path);
+        const target = this.find(root, {
+            path: parentPath,
+            parentPath: [],
+            issues: []
+        });
+        // skip if target can't be resolved (track issue)
+        if (!target) {
+            // TODO: track issue
+            console.warn(`[CollectionModel/updateValue] no target to update`);
+            // stop processing
+            return;
+        }
+        console.warn(`[CollectionModel/updateValue] updating target`, { target, childKey });
+        // set value
+        this.setValue(target, childKey, value);
+        console.warn(`[CollectionModel/updateValue] updated value for "${path.join('.')}" to:`, value);
+    }
+    setValue(target, key, data) {
+        // update root value
+        if (target === this.data.fields) {
+            console.debug(`[CollectionModel/setValue] updating "fields" at "${key}" to:`, data);
+            // delete entry if there's no data
+            if (data === null || data === undefined) {
+                console.debug(`[CollectionModel/setValue] deleting "fields" at "${key}"`);
+                delete target[key];
+            }
+            // or pave over if entry
+            else {
+                console.debug(`[CollectionModel/setValue] setting "fields" at "${key}" to:`, data);
+                target[key] = data;
+            }
+        }
+        // update list value
+        else if (target.type === 'list') {
+            // add back item if it's gone
+            const items = target.value;
+            const itemIndex = items.findIndex(item => item.id === key);
+            if (itemIndex < 0) {
+                items.push(data);
+            }
+            // or pave over value
+            else {
+                console.debug(`[CollectionModel/setValue] updating ListField at "${key}" to:`, data);
+                items[itemIndex] = data;
+            }
+        }
+        // or update object value
+        else if (target.type === 'object') {
+            console.debug(`[CollectionModel/setValue] updating ObjectField at "${key}" to:`, data);
+            // delete entry if there's no data
+            if (data === null || data === undefined) {
+                console.debug(`[CollectionModel/setValue] deleting ObjectField at "${key}"`);
+                delete target.value[key];
+            }
+            // or pave over with update
+            else {
+                console.debug(`[CollectionModel/setValue] updating ObjectField at "${key}" to:`, data);
+                target.value[key] = data;
+            }
+        }
+        // or ignore (this should never happen)
+        else {
+            console.warn(`[CollectionModel/setValue] invalid parent found at path "${key}"`, target);
+        }
+    }
+    find(fields, context) {
+        // return fields if there's no path
+        const { path, parentPath } = context;
+        if (path.length === 0) {
+            console.debug(`[CollectionModel/find] returning Collection.fields for: ${parentPath.join('.')}`);
+            return fields;
+        }
+        console.debug(`[CollectionModel/find] resolving content target: ${path.join('.')}`, { path, parentPath, fields, context });
+        // add item (if required)
+        const [key, ...remainingPath] = path;
+        const fieldValue = fields[key];
+        if (!fieldValue) {
+            console.warn(`[CollectionModel/find] unable to resolve top-level field "${key}" in "${parentPath.join('.')}"`);
+            return undefined;
+        }
+        // return item if there are no more components
+        if (remainingPath.length === 0) {
+            console.debug(`[CollectionModel/find] no more components - returning field value "${key}" at: ${path.join('.')}`);
+            return fieldValue;
+        }
+        // resolve value
+        else {
+            console.debug(`[CollectionModel/find] drilling into top-level value for "${key}": ${remainingPath.join('.')}`);
+            return this.findInValue(fieldValue, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, key] }));
+        }
+    }
+    findInValue(data, context) {
+        // return item if there's no more path components
+        const { path, parentPath } = context;
+        if (path.length === 0) {
+            console.debug(`[CollectionModel/findInValue] return leaf value "${parentPath.join('.')}":`, data);
+            return data;
+        }
+        // or return undefined if there's nothing here
+        else if (data === undefined || data === null) {
+            console.warn(`[CollectionModel/findInValue] encountered empty Value while navigating "${path.join('.')}" at "${parentPath.join('.')}"`);
+            return data;
+        }
+        // or recurse into an array
+        else if (data.type === 'list') {
+            // skip if entry isn't found
+            const value = data.value;
+            const [itemId, ...remainingPath] = path;
+            const item = value.find(item => item.id === itemId);
+            if (!item) {
+                console.warn(`[CollectionModel/findInValue] unable to find array item with ID "${itemId}" at "${parentPath.join('.')}"`);
+                return undefined;
+            }
+            // or recurse
+            else {
+                console.debug(`[CollectionModel/findInValue] drilling into item with ID "${itemId}" at "${remainingPath.join('.')}"`, item);
+                return this.findInValue(item, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, itemId] }));
+            }
+        }
+        // or recurse into an object
+        else if (data.type === 'object') {
+            // skip if there's no value for the key
+            const [entryKey, ...remainingPath] = path;
+            const entry = data.value[entryKey];
+            if (!entry) {
+                console.warn(`[CollectionModel/findInValue] unable to find object entry for key "${entryKey}" at "${parentPath.join('.')}"`);
+                return undefined;
+            }
+            // or recurse
+            else {
+                return this.findInValue(entry, Object.assign(Object.assign({}, context), { path: remainingPath, parentPath: [...parentPath, entryKey] }));
+            }
+        }
+        // or blow up
+        else {
+            throw new errors_1.IllegalStateError(`Unable to recurse into value at "${parentPath.join('.')}" for type "${data.type}"`);
+        }
+    }
+    static from(data) {
+        return new CollectionModel(data);
+    }
+    static fromDraft(data) {
+        const now = Date.now();
+        return new CollectionModel(Object.assign(Object.assign({}, data), { __root: 'collection', id: Collection_1.Collection.Id.draft, fields: {}, files: [], collections: [], errors: true, state: 'draft', createdOn: now, updatedOn: now }));
+    }
+}
+exports.CollectionModel = CollectionModel;
+function splitRoot(collection, rootPath) {
+    // fail if there are no path elements
+    if (rootPath.length === 0) {
+        throw new errors_1.ArgumentError('Path elements must have a list one segment');
+    }
+    // blow up if the root's not the fields (for now - we'll expand later)
+    const [rootComponent, ...path] = rootPath;
+    if (rootComponent !== 'fields') {
+        throw new errors_1.ArgumentError(`Unrecognized Collection root "${rootComponent}"`);
+    }
+    // return split root
+    return {
+        root: collection[rootComponent],
+        path
+    };
+}
+function splitPath(path) {
+    // fail if there are no path elements
+    if (path.length === 0) {
+        throw new errors_1.ArgumentError('Path elements must have a list one segment');
+    }
+    // split
+    const childIndex = path.length - 1;
+    return {
+        parentPath: path.slice(0, childIndex),
+        childKey: path[childIndex]
+    };
+}

package/dist/schema/CollectionSnapshot.d.ts

@@ -0,0 +1,11 @@
+import { Tagged } from 'type-fest';
+import { RequiredBy } from '../types';
+import type { Collection } from './Collection';
+export type CollectionSnapshot = RequiredBy<Pick<Collection.Data, Exclude<Collection.Data.Props.Id, 'id'> | Collection.Data.Props.Content | 'createdOn' | 'updatedOn' | 'changeSetId'>, 'changeSetId'> & {
+    id: CollectionSnapshot.Id;
+};
+export declare namespace CollectionSnapshot {
+    type Id = Tagged<string, 'CollectionSnapshot.Id'>;
+    type Prop = keyof CollectionSnapshot;
+    const props: ReadonlyArray<Prop>;
+}

package/dist/schema/CollectionSnapshot.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionSnapshot = void 0;
+// extension
+var CollectionSnapshot;
+(function (CollectionSnapshot) {
+    CollectionSnapshot.props = [
+        'id', 'groupId', 'type', 'brand', 'language', 'version', 'name', 'tags',
+        'fields',
+        'changeSetId', 'createdOn', 'updatedOn'
+    ];
+})(CollectionSnapshot || (exports.CollectionSnapshot = CollectionSnapshot = {}));

package/dist/schema/Fields.d.ts

@@ -0,0 +1,31 @@
+import { Transform } from '../types';
+import { EnumField, Field, RichTextField, TextField } from './field';
+import { Optional } from './Optional';
+export type Fields = Record<string, Optional.Maybe<Field.Type>>;
+export declare namespace Fields {
+    type Required<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends _Optional<Field.Type> ? never : key]: TFields[key];
+    };
+    type Optional<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends _Optional<Field.Type> ? key : never]: TFields[key];
+    };
+    type OptionalKeys<TFields extends Fields> = keyof Optional<TFields>;
+    type UnwrapOptional<TFields extends Fields> = {
+        [key in keyof TFields]: Optional.InnerType<TFields[key]>;
+    };
+    type Override<TFields extends Fields> = Transform<TFields, Partial<TFields>>;
+    type TextFields<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends TextField ? key : TFields[key] extends _Optional<TextField> ? key : never]: TFields[key];
+    };
+    type StringField = TextField | EnumField;
+    type StringFields<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends StringField ? key : TFields[key] extends _Optional<StringField> ? key : never]: TFields[key];
+    };
+    type TextLikeField = TextField | RichTextField | EnumField;
+    type TextLikeFields<TFields extends Fields> = {
+        [key in keyof TFields as TFields[key] extends TextLikeField ? key : TFields[key] extends _Optional<TextLikeField> ? key : never]: TFields[key];
+    };
+    function unwrap<TFields extends Fields>(fields: TFields): UnwrapOptional<TFields>;
+}
+type _Optional<T extends Optional.Content> = Optional<T>;
+export {};

package/dist/schema/Fields.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fields = void 0;
+const Optional_1 = require("./Optional");
+// extension
+var Fields;
+(function (Fields) {
+    // helpers
+    function unwrap(fields) {
+        return Object.entries(fields).reduce((fields, [key, field]) => {
+            // unwrap field
+            const { schema } = Optional_1.Optional.unwrap(field);
+            // bind it
+            const data = fields;
+            data[key] = schema;
+            // keep reducing
+            return fields;
+        }, {});
+    }
+    Fields.unwrap = unwrap;
+})(Fields || (exports.Fields = Fields = {}));

package/dist/schema/Form.d.ts

@@ -0,0 +1,31 @@
+import { BooleanField } from './field';
+import { Fields } from './Fields';
+import { Optional } from './Optional';
+export declare class Form<TFields extends Fields = Fields> {
+    readonly name: string;
+    readonly description?: string;
+    readonly version: number;
+    readonly fields: TFields;
+    readonly editableFields: Fields.UnwrapOptional<TFields>;
+    readonly consentFields?: Fields.UnwrapOptional<Form.ConsentFields>;
+    private constructor();
+    static create<TFields extends Fields>(args: Form.FactoryArgs<TFields>): Form<TFields>;
+}
+export declare namespace Form {
+    type BaseArgs = {
+        name: string;
+        description?: string;
+        version: number;
+    };
+    export type FactoryArgs<TFields extends Fields> = BaseArgs & {
+        fields: TFields;
+        consentFields?: ConsentFields;
+    };
+    export type ConstructorArgs<TFields extends Fields> = BaseArgs & {
+        fields: TFields;
+        editableFields: Fields.UnwrapOptional<TFields>;
+        consentFields?: Fields.UnwrapOptional<ConsentFields>;
+    };
+    export type ConsentFields = Record<string, Optional.Maybe<BooleanField>>;
+    export {};
+}

package/dist/schema/Form.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Form = void 0;
+const Fields_1 = require("./Fields");
+// class
+class Form {
+    constructor(args) {
+        // initialize instance variables
+        this.name = args.name;
+        this.description = args.description;
+        this.version = args.version;
+        this.fields = args.fields;
+        this.editableFields = args.editableFields;
+        this.consentFields = args.consentFields;
+    }
+    static create(args) {
+        // create new form
+        return new Form(Object.assign(Object.assign({}, args), { editableFields: Fields_1.Fields.unwrap(args.fields), consentFields: args.consentFields
+                ? Fields_1.Fields.unwrap(args.consentFields)
+                : undefined }));
+    }
+}
+exports.Form = Form;

package/dist/schema/LinkedCollectionModel.d.ts

@@ -0,0 +1,9 @@
+import { Collection } from './Collection';
+/**
+ * Collection model with refs resolved to values
+ */
+export declare class LinkedCollectionModel<TCollection extends Collection> {
+    readonly data: Collection.LinkedData<TCollection>;
+    constructor(data: Collection.LinkedData<TCollection>);
+    static fromCollectionData<TCollection extends Collection>(unlinkedData: Collection.Data<TCollection>): LinkedCollectionModel<TCollection>;
+}

package/dist/schema/LinkedCollectionModel.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedCollectionModel = void 0;
+const LinkedData_1 = require("./LinkedData");
+/**
+ * Collection model with refs resolved to values
+ */
+class LinkedCollectionModel {
+    constructor(data) {
+        this.data = data;
+    }
+    static fromCollectionData(unlinkedData) {
+        // transform
+        const linkedData = LinkedData_1.LinkedData.resolveStatic({ unlinkedData });
+        // return linked page model
+        return new LinkedCollectionModel(linkedData);
+    }
+}
+exports.LinkedCollectionModel = LinkedCollectionModel;

package/dist/schema/LinkedData.d.ts

@@ -0,0 +1,44 @@
+import { Tagged } from 'type-fest';
+import { ReadonlyObjectDeep } from 'type-fest/source/readonly-deep';
+import { Asset } from './Asset';
+import { Collection } from './Collection';
+import { DynamicPagesField, Field } from './field';
+import { Page } from './Page';
+export declare namespace LinkedData {
+    /**
+     * Link data, only resolving static links
+     */
+    function resolveStatic<TLinked>(args: Omit<LinkArgs, 'resolvers'>): TLinked;
+    /**
+     * Link data, resolving static and dynamic links
+     */
+    function resolve<TLinked>(args: LinkArgs): Promise<TLinked>;
+    type LinkArgs = {
+        unlinkedData: UnlinkedData;
+        resolvers: DynamicResolvers;
+        persona?: string;
+        stores?: TransformFromStores;
+    };
+    type UnlinkedData = ReadonlyObjectDeep<any>;
+    type StaticallyLinkedData = Tagged<UnlinkedData, 'linked.statically'>;
+    type TransformFromStores = {
+        assets?: ReadonlyArray<Asset.Linked>;
+        collections?: ReadonlyArray<Collection.Data.AsLink>;
+    };
+    type References = {
+        pages: Map<Page.Id, Page.Data>;
+        collections: Map<Collection.Id, Collection.Data.AsLink>;
+        assets: Map<Asset.Id, Asset.Linked>;
+    };
+    type UnlinkedReferences = {
+        pageRefs: Map<Page.Id, Field.Data.Page[]>;
+        collectionRefs: Map<Collection.Id, Field.Data.Collection.Ref[]>;
+        assetRefs: Map<Asset.Id, Asset[]>;
+        dynamicPages: Field.Data.DynamicPages[];
+    };
+    type PageQuery = DynamicPagesField.Query;
+    type PageResolver = (value: PageQuery) => Promise<Page.Data.AsPreview[]>;
+    type DynamicResolvers = {
+        page: PageResolver;
+    };
+}