@nascentdigital/funnel-core 4.4.4

package/dist/schema/Block.d.ts

@@ -0,0 +1,105 @@
+import { Transform } from '../types';
+import { BlockLayout } from '../ui/block-layout';
+import { Field } from './field';
+import { Fields } from './Fields';
+import { Optional } from './Optional';
+export declare class Block<TId extends string = string, TFields extends Fields = any, TConfig extends Block.Config = any> {
+    readonly type = "block";
+    readonly id: TId;
+    readonly name: string;
+    readonly hint?: string;
+    readonly required: boolean;
+    readonly version: number;
+    readonly fields: TFields;
+    readonly editableFields: Fields.UnwrapOptional<TFields>;
+    readonly config: Block.Config.UnwrapOptional<TConfig>;
+    readonly getConfig?: Block.GetConfig<TConfig, TFields>;
+    readonly getLayout?: Block.GetLayout<TConfig, TFields>;
+    private constructor();
+    optional(): Optional<Block<TId, TFields, TConfig>>;
+    unwrap(): this;
+    modify(args: Block.ModifyArgs<TId, TFields, TConfig>): Block<TId, TFields, TConfig>;
+    rename(name: string): Block<TId, TFields, TConfig>;
+    hide(...keys: ReadonlyArray<Fields.OptionalKeys<TFields>>): Block<TId, TFields, TConfig>;
+    override(override: Fields.Override<TFields>): Block<TId, TFields, TConfig>;
+    extend<TAdditionalFields extends Fields>(fields: TAdditionalFields): Block<TId, TFields & TAdditionalFields, TConfig>;
+    static create<TId extends string, TFields extends Fields, TConfig extends Block.Config>(args: Block.FactoryArgs<TId, TFields, TConfig>): Block<TId, TFields, TConfig>;
+}
+export declare namespace Block {
+    type GetConfig<TConfig extends Config = Config, TFields extends Fields = Fields> = Transform<GetConfig.Args<TConfig, TFields>, GetConfig.Result<TConfig>>;
+    namespace GetConfig {
+        type Args<TConfig extends Config, TFields extends Fields> = {
+            config: Partial<Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            configSchema: Config.UnwrapOptional<TConfig>;
+            fields: Partial<Data.ForFields<TFields>> | Partial<LinkedData.ForFields<TFields>>;
+        };
+        type Result<TConfig extends Config> = {
+            updatedConfig?: Partial<Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            defaultConfig?: Partial<Data.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            updatedConfigSchema?: Partial<Config.UnwrapOptional<TConfig>>;
+        };
+    }
+    type GetLayout<TConfig extends Config = Config, TFields extends Fields = Fields> = Transform<GetLayout.Args<TConfig, TFields>, BlockLayout>;
+    namespace GetLayout {
+        type Args<TConfig extends Config, TFields extends Fields> = {
+            config: Partial<Data.ForConfig<Config.UnwrapOptional<TConfig>>> | Partial<LinkedData.ForConfig<Config.UnwrapOptional<TConfig>>>;
+            fields: Partial<Data.ForFields<TFields>> | Partial<LinkedData.ForFields<TFields>>;
+        };
+    }
+    type Config = Record<string, Optional.Maybe<Field.Type.Simple.Configuration>>;
+    namespace Config {
+        type UnwrapOptional<TConfig extends Config> = {
+            [key in keyof TConfig]: Optional.InnerType<TConfig[key]>;
+        };
+    }
+    type Data<T extends Block = Block> = {
+        type: 'block';
+        id: T['id'];
+        version: number;
+        config: Data.ForConfig<T['config']>;
+        fields: Data.ForFields<T['fields']>;
+    };
+    namespace Data {
+        type ForFields<T extends Fields = Fields> = {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? never : key]: Field.Data.ForOptionalType<T[key]>;
+        } & {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? key : never]?: Field.Data.ForOptionalType<T[key]>;
+        };
+        type ForOptional<T extends Optional.Maybe<Block> = Optional.Maybe<Block>> = T extends Optional<Block> ? Data<Optional.InnerType<T>> | undefined : T extends Block ? Data<T> : never;
+        type ForConfig<T extends Config = Config> = {
+            name?: string;
+        } & {
+            [key in keyof T]: Field.Data<Optional.InnerType<T[key]>>;
+        };
+    }
+    type LinkedData<T extends Block = Block> = Omit<Data<T>, 'fields'> & {
+        fields: LinkedData.ForFields<T['fields']>;
+    };
+    namespace LinkedData {
+        type ForFields<T extends Fields = Fields> = {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? never : key]: Field.LinkedData.ForOptionalType<T[key]>;
+        } & {
+            [key in keyof T as T[key] extends Optional<Field.Type> ? key : never]?: Field.LinkedData.ForOptionalType<T[key]>;
+        };
+        type ForOptional<T extends Optional.Maybe<Block> = Optional.Maybe<Block>> = T extends Optional<Block> ? LinkedData<Optional.InnerType<T>> | undefined : T extends Block ? LinkedData<T> : never;
+        type ForConfig<T extends Config = Config> = {
+            name?: string;
+        } & {
+            [key in keyof T]: Field.LinkedData<Optional.InnerType<T[key]>>;
+        };
+    }
+    type ConstructorArgs<TId extends string, TFields extends Fields, TConfig extends Config = Config> = {
+        id: TId;
+        name: string;
+        hint?: string;
+        required?: boolean;
+        version: number;
+        fields: TFields;
+        editableFields: Fields.UnwrapOptional<TFields>;
+        config?: TConfig;
+        getConfig?: GetConfig<TConfig, TFields>;
+        getLayout?: GetLayout<TConfig, TFields>;
+    };
+    type ModifyArgs<TId extends string, TFields extends Fields, TConfig extends Config> = Partial<Pick<ConstructorArgs<TId, TFields, TConfig>, 'name' | 'hint' | 'required'>>;
+    type FactoryArgs<TId extends string, TFields extends Fields, TConfig extends Config = Config> = Omit<ConstructorArgs<TId, TFields, TConfig>, 'editableFields' | 'required'>;
+}

package/dist/schema/Block.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = void 0;
+const errors_1 = require("../errors");
+const Fields_1 = require("./Fields");
+const Optional_1 = require("./Optional");
+// class
+class Block {
+    constructor(args) {
+        var _a;
+        this.type = 'block';
+        // fail if name key/id is included in config
+        if (args.config && 'name' in args.config) {
+            throw new errors_1.ArgumentError('Block config schemas reserve the "name" key for the built-in name property.');
+        }
+        // initialize instance variables
+        this.id = args.id;
+        this.name = args.name;
+        this.hint = args.hint;
+        this.required = (_a = args.required) !== null && _a !== void 0 ? _a : true;
+        this.version = args.version;
+        this.fields = args.fields;
+        this.editableFields = args.editableFields;
+        this.config = args.config
+            ? Object.entries(args.config).reduce((fields, [fieldId, field]) => {
+                fields[fieldId] = field.unwrap();
+                return fields;
+            }, {})
+            : {};
+        this.getConfig = args.getConfig;
+        this.getLayout = args.getLayout;
+    }
+    optional() {
+        return new Optional_1.Optional(this);
+    }
+    unwrap() {
+        return this;
+    }
+    modify(args) {
+        // create new block (re-map required fields)
+        return new Block(Object.assign({ id: this.id, name: this.name, hint: this.hint, required: this.required, version: this.version, fields: this.fields, editableFields: this.editableFields, config: this.config, getConfig: this.getConfig, getLayout: this.getLayout }, args));
+    }
+    rename(name) {
+        return this.modify({ name });
+    }
+    hide(...keys) {
+        // create new block with removed fields
+        return new Block({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            version: this.version,
+            required: this.required,
+            fields: this.fields,
+            editableFields: keys.reduce((fields, key) => {
+                // handle field if not already pruned
+                const field = fields[key];
+                if (field) {
+                    // throw if field is required
+                    if (field.required) {
+                        throw new errors_1.InvalidOperationError(`Cannot hide required field: ${String(key)} in block: ${this.name}`);
+                    }
+                    // otherwise delete field if not already pruned
+                    else {
+                        delete fields[key];
+                    }
+                }
+                // keep reducing
+                return fields;
+            }, Object.assign({}, this.editableFields)),
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout
+        });
+    }
+    override(override) {
+        // get overrides from function
+        const overrides = override(this.fields);
+        // create new block with persisted field spec and overridden fields in unwrapped fields
+        return new Block({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            version: this.version,
+            required: this.required,
+            fields: this.fields,
+            editableFields: Object.assign(Object.assign({}, this.editableFields), overrides),
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout
+        });
+    }
+    extend(fields) {
+        return new Block({
+            id: this.id,
+            name: this.name,
+            hint: this.hint,
+            required: this.required,
+            version: this.version,
+            fields: Object.assign(Object.assign({}, this.fields), fields),
+            editableFields: Object.assign(Object.assign({}, this.editableFields), Fields_1.Fields.unwrap(fields)),
+            config: this.config,
+            getConfig: this.getConfig,
+            getLayout: this.getLayout
+        });
+    }
+    static create(args) {
+        // create new block with both field spec and unwrapped fields
+        return new Block({
+            id: args.id,
+            name: args.name,
+            hint: args.hint,
+            version: args.version,
+            fields: args.fields,
+            editableFields: Fields_1.Fields.unwrap(args.fields),
+            config: args.config,
+            getConfig: args.getConfig,
+            getLayout: args.getLayout
+        });
+    }
+}
+exports.Block = Block;

package/dist/schema/ChangeSet.d.ts

@@ -0,0 +1,108 @@
+import { StringKeyOf, Tagged } from 'type-fest';
+import { Language } from '../regionalization';
+import { PartialBy } from '../types';
+import { MimeType } from '../ui';
+import type { Asset } from './Asset';
+import type { Collection } from './Collection';
+import type { Page } from './Page';
+export declare class ChangeSet {
+    readonly brand: string;
+    readonly id: ChangeSet.Id;
+    readonly groupId: ChangeSet.GroupId;
+    private _name;
+    private _changes;
+    readonly createdOn: number;
+    readonly updatedOn: number;
+    private _publishedOn?;
+    private _modified;
+    constructor(args: ChangeSet.ConstructorArgs);
+    get isDefault(): boolean;
+    get name(): string;
+    set name(name: string);
+    get status(): ChangeSet.Status;
+    get errors(): boolean;
+    get publishedOn(): number | undefined;
+    set publishedOn(publishedOn: number | undefined);
+    get modified(): boolean;
+    get changes(): ReadonlyArray<ChangeSet.Change>;
+    get pageChanges(): ChangeSet.Change.ForPage[];
+    addPageChange(userId: string, change: Omit<ChangeSet.Change.ForPage, 'attribution'>): void;
+    deletePageChange(id: Page.Id): void;
+    get collectionChanges(): ChangeSet.Change.ForCollection[];
+    addCollectionChange(userId: string, change: Omit<ChangeSet.Change.ForCollection, 'attribution'>): void;
+    deleteCollectionChange(id: Collection.Id): void;
+    get assetChanges(): ChangeSet.Change.ForAsset[];
+    addAssetChange(userId: string, change: Omit<ChangeSet.Change.ForAsset, 'attribution'>): void;
+    deleteAssetChange(id: Asset.Id): void;
+    toData(): ChangeSet.Data;
+}
+export declare namespace ChangeSet {
+    type Id = Tagged<string, 'ChangeSet.Id'>;
+    type GroupId = Tagged<string, 'ChangeSet.GroupId'> | GroupId.Global;
+    namespace GroupId {
+        const global: "__global";
+        type Global = typeof global;
+    }
+    type Status = 'commited' | 'ready' | 'incomplete' | 'errors';
+    type Change = Change.ForPage | Change.ForCollection | Change.ForAsset;
+    namespace Change {
+        export type Id = Change['id'];
+        export type Type = 'create' | 'update' | 'unpublish' | 'delete';
+        type Base = {
+            type: Type;
+            name: string;
+            errors: boolean;
+            attribution: Attribution[];
+        };
+        export type Attribution = {
+            userId: string;
+            updatedOn: number;
+        };
+        export type ForPage = Base & {
+            __type: 'page';
+            id: Page.Id;
+            schema: Page.Type;
+            region: string;
+            language: Language;
+            slug?: string;
+        };
+        export type ForCollection = Base & {
+            __type: 'collection';
+            id: Collection.Id;
+            groupId: Collection.GroupId;
+            schema: Collection.Type;
+            language: Language;
+        };
+        export type ForAsset = Base & {
+            __type: 'asset';
+            id: Asset.Id;
+            mimeType: MimeType;
+        };
+        export {};
+    }
+    type Data = {
+        brand: string;
+        id: Id;
+        groupId: GroupId;
+        name: string;
+        changes: Change[];
+        errors: boolean;
+        createdOn: number;
+        updatedOn: number;
+        publishedOn?: number;
+    };
+    namespace Data {
+        type Prop = StringKeyOf<Data>;
+        const props: ReadonlyArray<Prop>;
+        type New = PartialBy<Omit<Data, 'id' | 'createdOn' | 'updatedOn' | 'publishedOn'>, 'name' | 'errors' | 'changes'>;
+        namespace New {
+            function filter(data: Data | New): data is New;
+        }
+        type Grouped = {
+            groupId: GroupId;
+            latest: Data;
+            total: number;
+        };
+    }
+    type ConstructorArgs = Omit<Data, 'errors'>;
+}

package/dist/schema/ChangeSet.js

@@ -0,0 +1,187 @@
+"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.ChangeSet = void 0;
+// model
+class ChangeSet {
+    constructor(args) {
+        // initialize instance variables
+        this.brand = args.brand;
+        this.id = args.id;
+        this.groupId = args.groupId;
+        this._name = args.name;
+        this._changes = args.changes.slice();
+        this.createdOn = args.createdOn;
+        this.updatedOn = args.updatedOn;
+        this._publishedOn = args.publishedOn;
+        this._modified = false;
+    }
+    get isDefault() {
+        return this.groupId === ChangeSet.GroupId.global;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(name) {
+        if (this._name !== name) {
+            this._name = name;
+            this._modified = true;
+        }
+    }
+    get status() {
+        // mark published if live
+        const { _publishedOn, _changes } = this;
+        if (_publishedOn) {
+            return 'commited';
+        }
+        // mark ready if there are no errors
+        const errors = _changes.filter(change => change.errors);
+        if (errors.length === 0) {
+            return 'ready';
+        }
+        // or incomplete if there are any drafts in the errors
+        else if (errors.some(change => change.type === 'create')) {
+            return 'incomplete';
+        }
+        // or errors
+        else {
+            return 'errors';
+        }
+    }
+    get errors() {
+        return this._changes.some(change => change.errors);
+    }
+    get publishedOn() {
+        return this._publishedOn;
+    }
+    set publishedOn(publishedOn) {
+        if (this._publishedOn !== publishedOn) {
+            this._publishedOn = publishedOn;
+            this._modified = true;
+        }
+    }
+    get modified() {
+        return this._modified;
+    }
+    get changes() {
+        return this._changes;
+    }
+    get pageChanges() {
+        return this._changes.filter(change => change.__type === 'page');
+    }
+    addPageChange(userId, change) {
+        // apply change
+        addChange({
+            changes: this._changes,
+            change,
+            userId
+        });
+        // mark modified
+        this._modified = true;
+    }
+    deletePageChange(id) {
+        this._changes = this.changes.filter(change => change.id !== id);
+        this._modified = true;
+    }
+    get collectionChanges() {
+        return this._changes.filter(change => change.__type === 'collection');
+    }
+    addCollectionChange(userId, change) {
+        // apply change
+        addChange({
+            changes: this._changes,
+            change,
+            userId
+        });
+        // mark modified
+        this._modified = true;
+    }
+    deleteCollectionChange(id) {
+        this._changes = this.changes.filter(change => change.id !== id);
+        this._modified = true;
+    }
+    get assetChanges() {
+        return this._changes.filter(change => change.__type === 'asset');
+    }
+    addAssetChange(userId, change) {
+        // apply change
+        addChange({
+            changes: this._changes,
+            change,
+            userId
+        });
+        // mark modified
+        this._modified = true;
+    }
+    deleteAssetChange(id) {
+        this._changes = this.changes.filter(change => change.id !== id);
+        this._modified = true;
+    }
+    toData() {
+        const { brand, id, groupId, name, _changes, errors, createdOn, updatedOn, publishedOn } = this;
+        return {
+            brand,
+            id,
+            groupId,
+            name,
+            changes: _changes,
+            errors,
+            createdOn,
+            updatedOn,
+            publishedOn
+        };
+    }
+}
+exports.ChangeSet = ChangeSet;
+// extension
+(function (ChangeSet) {
+    let GroupId;
+    (function (GroupId) {
+        GroupId.global = '__global';
+    })(GroupId = ChangeSet.GroupId || (ChangeSet.GroupId = {}));
+    let Data;
+    (function (Data) {
+        Data.props = [
+            'brand', 'id', 'groupId', 'name', 'changes', 'errors', 'createdOn', 'updatedOn', 'publishedOn'
+        ];
+        let New;
+        (function (New) {
+            function filter(data) {
+                return !('id' in data);
+            }
+            New.filter = filter;
+        })(New = Data.New || (Data.New = {}));
+    })(Data = ChangeSet.Data || (ChangeSet.Data = {}));
+})(ChangeSet || (exports.ChangeSet = ChangeSet = {}));
+function addChange({ changes, change, userId }) {
+    // update existing page
+    const updatedOn = Date.now();
+    const changeIndex = changes.findIndex(({ id }) => change.id === id);
+    if (changeIndex >= 0) {
+        // update attribution (skip if it's the same change by the same user)
+        const _a = changes[changeIndex], { type, attribution } = _a, existingChange = __rest(_a, ["type", "attribution"]);
+        const lastAttribution = attribution.length > 0
+            ? attribution[attribution.length - 1]
+            : undefined;
+        if ((lastAttribution === null || lastAttribution === void 0 ? void 0 : lastAttribution.userId) !== userId || change.type !== type) {
+            attribution.push({ userId, updatedOn });
+        }
+        // update change
+        changes[changeIndex] = Object.assign(Object.assign(Object.assign({}, existingChange), change), { type,
+            attribution });
+    }
+    // or add a new one
+    else {
+        changes.push(Object.assign(Object.assign({}, change), { attribution: [{ userId, updatedOn }] }));
+    }
+}