@nascentdigital/funnel-core 4.4.4

package/dist/ui/fields/FieldList.d.ts

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+import * as Schema from '../../schema';
+import { EventBus } from '../../services';
+import { Field } from './Field';
+import { FieldValidator } from './FieldValidator';
+import { ObjectField } from './ObjectField';
+export declare class FieldList {
+    readonly schema: FieldList.ListSchema;
+    readonly composition: FieldList.ListComposition;
+    private _items;
+    readonly id: string;
+    readonly name: string;
+    readonly required: boolean;
+    private readonly eventBus;
+    readonly initialValue: FieldList.ListValue | undefined;
+    readonly publishedValue: FieldList.ListValue | undefined;
+    private readonly _validator;
+    private _errors;
+    private _optIn?;
+    private _optOut?;
+    constructor(args: FieldList.ConstructorArgs);
+    get events$(): Observable<FieldList.Event>;
+    get items(): ReadonlyArray<FieldList.Item>;
+    get isNew(): boolean;
+    get exists(): boolean;
+    get valid(): boolean;
+    get filteredErrors(): readonly FieldValidator.Error[];
+    get error(): FieldValidator.Error | undefined;
+    get errors(): FieldValidator.Error[];
+    get hasValue(): boolean;
+    get value(): FieldList.ListValue | undefined;
+    set value(value: FieldList.ListValue | undefined);
+    get modified(): boolean;
+    get changed(): boolean;
+    get canOptOut(): boolean;
+    optIn(): void;
+    optOut(): void;
+    get optedOut(): boolean;
+    get shouldFocus(): boolean;
+    didFocus(): boolean;
+    validate(): ReadonlyArray<FieldValidator.Error>;
+    get canAdd(): boolean;
+    addItem({ schema: schemaId, id, ...value }: FieldList.ItemValue): FieldList.Item<Schema.ListField.Content.Type>;
+    removeItems(itemIds: ReadonlyArray<string>): void;
+    removeItem(itemId: string): void;
+    removeField(field: Field | ObjectField): void;
+    moveItem(fromIndex: number, toIndex: number): void;
+    reset(initialValue?: FieldList.ListValue | null): void;
+    clone(): FieldList;
+    private raiseEvent;
+}
+export declare namespace FieldList {
+    type ConstructorArgs = {
+        eventBus: EventBus;
+        schema: ListSchema;
+        id: string;
+        name: string;
+        initialValue?: ListValue;
+        publishedValue?: ListValue;
+        required: boolean;
+    };
+    type ListComposition = 'simple' | 'complex.single' | 'complex.multi' | 'mixed';
+    type ListSchema = Schema.ListField<Schema.ListField.Content>;
+    type ListValue = Schema.Field.Data<ListSchema>;
+    type ItemSchema = Schema.ListField.Content[keyof Schema.ListField.Content];
+    type Item<TItemSchema extends ItemSchema = ItemSchema> = {
+        schema: string;
+        id: string;
+        field: Field<TItemSchema> | ObjectField;
+    };
+    type ItemValue = Schema.ListField.Value.ForItem<Schema.ListField.Content>;
+    interface Event extends EventBus.Event<'FieldList', Event.Type> {
+        field: FieldList;
+    }
+    namespace Event {
+        type Type = 'changed' | 'validation';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/ui/fields/FieldList.js

@@ -0,0 +1,421 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.FieldList = void 0;
+const rxjs_1 = require("rxjs");
+const errors_1 = require("../../errors");
+const Schema = __importStar(require("../../schema"));
+const services_1 = require("../../services");
+const utils_1 = require("../../utils");
+const Field_1 = require("./Field");
+const FieldListValidator_1 = require("./FieldListValidator");
+const FieldValidator_1 = require("./FieldValidator");
+const ObjectField_1 = require("./ObjectField");
+// class
+class FieldList {
+    constructor(args) {
+        // initialize instance variables
+        this.eventBus = args.eventBus;
+        this.schema = args.schema;
+        this.composition = getListComposition(args.schema);
+        this._items = deserializeItems({
+            eventBus: args.eventBus,
+            schema: args.schema,
+            value: args.initialValue,
+            publishedValue: args.publishedValue,
+        });
+        this.id = args.id;
+        this.name = args.name;
+        this.required = args.required;
+        this.initialValue = args.initialValue;
+        this.publishedValue = args.publishedValue;
+        this._validator = new FieldListValidator_1.FieldListValidator(this.schema);
+        // validate
+        this._errors = this._validator.validate(this, this.value);
+    }
+    get events$() {
+        return this.eventBus.events$.pipe((0, rxjs_1.filter)(FieldList.Event.filter), (0, rxjs_1.filter)(e => e.field === this));
+    }
+    get items() {
+        return this._items;
+    }
+    get isNew() {
+        const { exists, initialValue } = this;
+        return exists && initialValue === undefined;
+    }
+    get exists() {
+        const { initialValue, _optIn = false, _optOut = false, schema: { required } } = this;
+        return (initialValue !== undefined && !_optOut) || required || _optIn;
+    }
+    get valid() {
+        return this.errors.length === 0;
+    }
+    get filteredErrors() {
+        return this._validator.filter(this._errors, 'all');
+    }
+    get error() {
+        return FieldValidator_1.FieldValidator.Error.mostRelevant(this.errors);
+    }
+    get errors() {
+        return [...this._errors, ...this._items.flatMap(item => item.field.errors)];
+    }
+    get hasValue() {
+        return this._items.length > 0;
+    }
+    get value() {
+        return this.exists
+            ?
+                {
+                    type: 'list',
+                    value: this._items.map(serializeItem).filter(utils_1.Value.isDefined)
+                }
+            : undefined;
+    }
+    set value(value) {
+        // ignore if the values are the same
+        if (utils_1.Value.equals(this.value, value)) {
+            return;
+        }
+        // update
+        const { eventBus, schema, publishedValue } = this;
+        this._items = deserializeItems({
+            eventBus,
+            schema,
+            value,
+            publishedValue
+        });
+        // revalidate
+        this.validate();
+        // raise event
+        this.raiseEvent('changed');
+    }
+    get modified() {
+        const { value, initialValue } = this;
+        return this._optIn || !utils_1.Value.equals(value, initialValue);
+    }
+    get changed() {
+        const { value, publishedValue } = this;
+        return !utils_1.Value.equals(value, publishedValue);
+    }
+    get canOptOut() {
+        return !this.schema.required;
+    }
+    optIn() {
+        // skip if required
+        const { schema } = this;
+        if (schema.required) {
+            return;
+        }
+        // set opt-in flag
+        this._optIn = true;
+        this.raiseEvent('changed');
+    }
+    optOut() {
+        // skip if required
+        const { schema } = this;
+        if (schema.required) {
+            return;
+        }
+        // clear value
+        this._optOut = true;
+        this._items = [];
+        this.raiseEvent('changed');
+    }
+    get optedOut() {
+        var _a;
+        return (_a = this._optOut) !== null && _a !== void 0 ? _a : false;
+    }
+    get shouldFocus() {
+        return false;
+    }
+    didFocus() {
+        return false;
+    }
+    validate() {
+        // validate (skip if nothing has changed)
+        const errors = this._validator.validate(this, this.value);
+        if (utils_1.Value.equals(errors, this._errors)) {
+            return this._errors;
+        }
+        // update errors
+        this._errors = errors;
+        // raise event
+        this.raiseEvent('validation');
+        // return errors
+        return errors;
+    }
+    get canAdd() {
+        const { schema, _items } = this;
+        return _items.length < schema.max;
+    }
+    addItem(_a) {
+        var { schema: schemaId, id } = _a, value = __rest(_a, ["schema", "id"]);
+        // create new item
+        const { eventBus, schema } = this;
+        const itemSchema = schema.itemTypes[schemaId];
+        const item = {
+            schema: schemaId,
+            id,
+            field: itemSchema.type === 'object'
+                ? new ObjectField_1.ObjectField({
+                    id,
+                    eventBus,
+                    schema: itemSchema,
+                    name: itemSchema.name,
+                    initialValue: value,
+                    publishedValue: undefined,
+                    required: true
+                })
+                : new Field_1.Field({
+                    id,
+                    eventBus,
+                    schema: itemSchema,
+                    name: itemSchema.name,
+                    initialValue: value,
+                    publishedValue: undefined,
+                    required: true
+                })
+        };
+        // add to list
+        this._items = [...this._items, item];
+        // revalidate
+        this.validate();
+        // raise event
+        this.raiseEvent('changed');
+        // return item
+        return item;
+    }
+    removeItems(itemIds) {
+        // remove item
+        const itemCount = this._items.length;
+        this._items = this._items.filter(({ id }) => !itemIds.includes(id));
+        // raise event (if there are changes)
+        if (this._items.length !== itemCount) {
+            // revalidate
+            this.validate();
+            // raise change
+            this.raiseEvent('changed');
+        }
+    }
+    removeItem(itemId) {
+        this.removeItems([itemId]);
+    }
+    removeField(field) {
+        // find item (or skip
+        const item = this._items.find(item => item.field === field);
+        if (!item) {
+            return;
+        }
+        // remove item
+        this.removeItems([item.id]);
+    }
+    moveItem(fromIndex, toIndex) {
+        // throw if from/to are out-of-bounds
+        const maxIndex = this._items.length - 1;
+        if (fromIndex < 0 || toIndex < 0 || fromIndex > maxIndex || toIndex > maxIndex) {
+            throw new errors_1.ArgumentError(`Move indices of ${fromIndex} -> ${toIndex} fall outside of range [${0}, ${maxIndex}]`);
+        }
+        // ignore if from/to are same
+        if (fromIndex === toIndex) {
+            return;
+        }
+        // create new items
+        const items = this._items.slice();
+        const [item] = items.splice(fromIndex, 1);
+        items.splice(toIndex, 0, item);
+        // update items
+        this._items = items;
+        // revalidate
+        this.validate();
+        // raise change
+        this.raiseEvent('changed');
+    }
+    reset(initialValue) {
+        // re-bind new initial values
+        if (initialValue || initialValue === null) {
+            // set items from current value
+            this._items = deserializeItems({
+                eventBus: this.eventBus,
+                schema: this.schema,
+                value: initialValue !== null && initialValue !== void 0 ? initialValue : undefined
+            });
+        }
+        //  reset each field if there's no initial value
+        else {
+            this._items.forEach(({ field }) => field.reset());
+        }
+        // revalidate
+        this.validate();
+        // raise final change
+        this.raiseEvent('changed');
+    }
+    clone() {
+        return new FieldList({
+            eventBus: this.eventBus,
+            schema: this.schema,
+            id: this.id,
+            name: this.name,
+            publishedValue: this.publishedValue,
+            initialValue: this.initialValue,
+            required: this.required
+        });
+    }
+    raiseEvent(type) {
+        this.eventBus.publish(FieldList.Event.create({ type, field: this }));
+    }
+}
+exports.FieldList = FieldList;
+// extension
+(function (FieldList) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'FieldList';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return services_1.EventBus.createEvent(Object.assign({ domain: 'FieldList' }, event));
+        }
+        Event.create = create;
+    })(Event = FieldList.Event || (FieldList.Event = {}));
+})(FieldList || (exports.FieldList = FieldList = {}));
+// helpers
+function getListComposition(schema) {
+    // throw if there are no item types
+    const itemTypes = Object.entries(schema.itemTypes);
+    if (itemTypes.length === 0) {
+        throw new errors_1.ArgumentError('Cannot have list with 0 types');
+    }
+    // tally types
+    let simpleCount = 0;
+    let complexCount = 0;
+    itemTypes.forEach(([, itemType]) => {
+        switch (itemType.type) {
+            case 'text':
+            case 'richtext':
+            case 'enum':
+            case 'boolean':
+            case 'date':
+            case 'timestamp':
+                simpleCount += 1;
+                break;
+            default:
+                complexCount += 1;
+                break;
+        }
+    });
+    // fail if types are mixed
+    if (simpleCount > 0 && complexCount > 0) {
+        return 'mixed';
+    }
+    else if (simpleCount > 0) {
+        return 'simple';
+    }
+    else if (complexCount === 1) {
+        return 'complex.single';
+    }
+    else {
+        return 'complex.multi';
+    }
+}
+function deserializeItems({ eventBus, schema: listSchema, value, publishedValue }) {
+    var _a, _b;
+    // convert values
+    const itemSchemas = listSchema.itemTypes;
+    const values = (_a = value === null || value === void 0 ? void 0 : value.value) !== null && _a !== void 0 ? _a : [];
+    const publishedValues = (_b = publishedValue === null || publishedValue === void 0 ? void 0 : publishedValue.value) !== null && _b !== void 0 ? _b : [];
+    return values
+        // drop any values that aren't supported
+        .filter(({ schema, type }) => {
+        const itemSchema = itemSchemas[schema];
+        return !!itemSchema && itemSchema.type === type;
+    })
+        // map the rest
+        .map((_a) => {
+        var { schema, id } = _a, item = __rest(_a, ["schema", "id"]);
+        // resolve schema
+        const itemSchema = itemSchemas[schema];
+        // create item
+        return {
+            schema,
+            id,
+            field: itemSchema.type === 'object'
+                ? new ObjectField_1.ObjectField({
+                    id: id,
+                    name: itemSchema.name,
+                    eventBus,
+                    schema: itemSchema,
+                    initialValue: item,
+                    publishedValue: Schema.ListField.Value.purifyItem(publishedValues.find(item => item.id === id)),
+                    required: true
+                })
+                : new Field_1.Field({
+                    id: id,
+                    name: itemSchema.name,
+                    eventBus,
+                    schema: itemSchema,
+                    initialValue: item,
+                    publishedValue: Schema.ListField.Value.purifyItem(publishedValues.find(item => item.id === id)),
+                    required: true
+                })
+        };
+    });
+}
+function serializeItem(item) {
+    var _a;
+    // ignore if item has no value
+    const { schema, id, field } = item;
+    const { value } = field;
+    if (value === undefined) {
+        return undefined;
+    }
+    // or return value
+    else {
+        return Object.assign({ schema,
+            id }, ((_a = field.value) !== null && _a !== void 0 ? _a : {}));
+    }
+}

package/dist/ui/fields/FieldListValidator.d.ts

@@ -0,0 +1,9 @@
+import type { ListField } from '../../schema/field/composite/ListField';
+import { FieldList } from './FieldList';
+import { FieldValidator } from './FieldValidator';
+export declare class FieldListValidator {
+    readonly schema: ListField;
+    constructor(schema: ListField);
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldList, rawData: any): FieldValidator.Error[];
+}

package/dist/ui/fields/FieldListValidator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldListValidator = void 0;
+const ValidatorHelper_1 = require("./validators/ValidatorHelper");
+// class
+class FieldListValidator {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        var _a;
+        // handle case where unset (fail if not optional)
+        const { value: rawValue } = (_a = rawData) !== null && _a !== void 0 ? _a : {};
+        const value = Array.isArray(rawValue) ? rawValue : [];
+        if (value.length === 0) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value })]
+                : [];
+        }
+        // fail if min isn't met
+        const errors = [];
+        const { min, max } = this.schema;
+        if (value.length < min) {
+            errors.push(ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'array.min', critical: true, value }));
+        }
+        // or if max is exceeded
+        else if (value.length > max) {
+            errors.push(ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'array.max', critical: true, value }));
+        }
+        // return errors
+        return errors;
+    }
+}
+exports.FieldListValidator = FieldListValidator;

package/dist/ui/fields/FieldModel.d.ts

@@ -0,0 +1,15 @@
+import { Field } from './Field';
+import { FieldList } from './FieldList';
+import { ObjectField } from './ObjectField';
+import * as Schema from '../../schema';
+export type FieldModel = Field | FieldList | ObjectField;
+export declare namespace FieldModel {
+    type Simple = Field | FieldList;
+    type Composite = ObjectField;
+    type Config = Field<Schema.Field.Type.Simple.Configuration>;
+    function filter(value: any): value is FieldModel;
+    type Event = Field.Event | FieldList.Event | ObjectField.Event;
+    namespace Event {
+        function filter(value: any): value is Event;
+    }
+}

package/dist/ui/fields/FieldModel.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldModel = void 0;
+const Field_1 = require("./Field");
+const FieldList_1 = require("./FieldList");
+const ObjectField_1 = require("./ObjectField");
+// extension
+var FieldModel;
+(function (FieldModel) {
+    // filter
+    function filter(value) {
+        return value &&
+            (value instanceof Field_1.Field
+                || value instanceof FieldList_1.FieldList
+                || value instanceof ObjectField_1.ObjectField);
+    }
+    FieldModel.filter = filter;
+    let Event;
+    (function (Event) {
+        function filter(value) {
+            return value &&
+                (Field_1.Field.Event.filter(value)
+                    || FieldList_1.FieldList.Event.filter(value)
+                    || ObjectField_1.ObjectField.Event.filter(value));
+        }
+        Event.filter = filter;
+    })(Event = FieldModel.Event || (FieldModel.Event = {}));
+})(FieldModel || (exports.FieldModel = FieldModel = {}));

package/dist/ui/fields/FieldSerializer.d.ts

@@ -0,0 +1,13 @@
+import * as Schema from '../../schema';
+import { EventBus } from '../../services';
+import { FieldModel } from './FieldModel';
+export declare namespace FieldSerializer {
+    type DeserializeFieldArgs = {
+        id: string;
+        eventBus: EventBus;
+        schema: Schema.Field.Type;
+        content: any | undefined;
+        snapshot: any | undefined;
+    };
+    function deserializeField({ id, eventBus, schema, content, snapshot }: DeserializeFieldArgs): FieldModel;
+}

package/dist/ui/fields/FieldSerializer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSerializer = void 0;
+const errors_1 = require("../../errors");
+const Field_1 = require("./Field");
+const FieldList_1 = require("./FieldList");
+const ObjectField_1 = require("./ObjectField");
+// namespace
+var FieldSerializer;
+(function (FieldSerializer) {
+    function deserializeField({ id, eventBus, schema, content, snapshot }) {
+        var _a;
+        // deserialize based on type
+        switch (schema.type) {
+            // unpack a simple field
+            case 'text':
+            case 'richtext':
+            case 'enum':
+            case 'boolean':
+            case 'date':
+            case 'timestamp':
+            case 'link':
+            case 'embedded.video':
+            case 'asset':
+            case 'dynamic.pages':
+            case 'collection':
+            case 'page':
+                return new Field_1.Field({
+                    eventBus,
+                    schema,
+                    id,
+                    name: schema.name,
+                    publishedValue: snapshot !== null && snapshot !== void 0 ? snapshot : undefined,
+                    initialValue: content !== null && content !== void 0 ? content : undefined,
+                    required: schema.required
+                });
+            // handle lists (may nest more complex types)
+            case 'list': {
+                // fail if we don't have any types in the list
+                const itemSchemas = Object.entries(schema.itemTypes);
+                if (itemSchemas.length === 0) {
+                    throw new errors_1.IllegalStateError(`ListField "${schema.name}" is defined without any itemTypes entries`);
+                }
+                // return list
+                return new FieldList_1.FieldList({
+                    eventBus,
+                    schema: schema,
+                    id,
+                    name: schema.name,
+                    publishedValue: snapshot !== null && snapshot !== void 0 ? snapshot : undefined,
+                    initialValue: content !== null && content !== void 0 ? content : undefined,
+                    required: schema.required
+                });
+            }
+            // or unpack a complex type (aka an object)
+            case 'object':
+                return new ObjectField_1.ObjectField({
+                    eventBus,
+                    schema,
+                    id,
+                    name: schema.name,
+                    publishedValue: snapshot !== null && snapshot !== void 0 ? snapshot : undefined,
+                    initialValue: content !== null && content !== void 0 ? content : undefined,
+                    required: schema.required
+                });
+            default:
+                throw new errors_1.NotImplementedError(`Unsupported content type for block field "${id}": ${(_a = schema.type) !== null && _a !== void 0 ? _a : 'Unknown'}`);
+        }
+    }
+    FieldSerializer.deserializeField = deserializeField;
+})(FieldSerializer || (exports.FieldSerializer = FieldSerializer = {}));