@nascentdigital/funnel-core 4.4.4

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

@@ -0,0 +1,19 @@
+import { Tagged } from 'type-fest';
+import { Field } from './Field';
+import { AssetValidator, DateValidator, EnumValidator, GenericValidator, LinkValidator, RichTextValidator, TextValidator, TimestampValidator } from './validators';
+export type FieldValidator = TextValidator | RichTextValidator | EnumValidator | DateValidator | TimestampValidator | LinkValidator | AssetValidator | GenericValidator;
+export declare namespace FieldValidator {
+    type Error = {
+        id: Error.Id;
+        critical: boolean;
+        visual: boolean;
+        message: string;
+    };
+    namespace Error {
+        type Id = Tagged<string, 'FieldValidator.Error'>;
+        type Level = 'none' | 'critical' | 'all';
+        function filter(error: Error, level: Level): boolean;
+        function mostRelevant(errors: ReadonlyArray<Error>): Error | undefined;
+    }
+    function create(field: Field): FieldValidator;
+}

package/dist/ui/fields/FieldValidator.js

@@ -0,0 +1,98 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldValidator = void 0;
+const Schema = __importStar(require("../../schema"));
+const validators_1 = require("./validators");
+// extension
+var FieldValidator;
+(function (FieldValidator) {
+    let Error;
+    (function (Error) {
+        // helpers
+        function filter(error, level) {
+            switch (level) {
+                case 'none':
+                    return false;
+                case 'critical':
+                    return error.critical;
+                default:
+                    return true;
+            }
+        }
+        Error.filter = filter;
+        function mostRelevant(errors) {
+            var _a, _b;
+            // skip if there are no errors
+            if (errors.length === 0) {
+                return undefined;
+            }
+            // get required, empty, or fallback
+            return (_b = (_a = errors.find(error => error.id === 'required')) !== null && _a !== void 0 ? _a : errors.find(error => error.id === 'empty')) !== null && _b !== void 0 ? _b : errors[0];
+        }
+        Error.mostRelevant = mostRelevant;
+    })(Error = FieldValidator.Error || (FieldValidator.Error = {}));
+    // methods
+    function create(field) {
+        // create validator for each schema type
+        const { schema } = field;
+        if (schema instanceof Schema.TextField) {
+            return new validators_1.TextValidator(schema, field);
+        }
+        else if (schema instanceof Schema.RichTextField) {
+            return new validators_1.RichTextValidator();
+        }
+        else if (schema instanceof Schema.EnumField) {
+            return new validators_1.EnumValidator(schema, field);
+        }
+        else if (schema instanceof Schema.DateField) {
+            return new validators_1.DateValidator(schema);
+        }
+        else if (schema instanceof Schema.TimestampField) {
+            return new validators_1.TimestampValidator(schema);
+        }
+        else if (schema instanceof Schema.LinkField) {
+            return new validators_1.LinkValidator(schema);
+        }
+        else if (schema instanceof Schema.AssetField) {
+            return new validators_1.AssetValidator(schema);
+        }
+        // otherwise, return a no-op validator (does nothing)
+        else {
+            return new validators_1.GenericValidator();
+        }
+    }
+    FieldValidator.create = create;
+})(FieldValidator || (exports.FieldValidator = FieldValidator = {}));

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

@@ -0,0 +1,75 @@
+import { Observable } from 'rxjs';
+import * as Schema from '../../schema';
+import { EventBus } from '../../services';
+import { Field } from './Field';
+import { FieldList } from './FieldList';
+import { FieldModel } from './FieldModel';
+import { FieldValidator } from './FieldValidator';
+export declare class ObjectField {
+    readonly schema: Schema.ObjectField;
+    readonly id: string;
+    readonly name: string;
+    readonly required: boolean;
+    readonly publishedValue: ObjectField.Value | undefined;
+    private readonly eventBus;
+    private readonly _content;
+    private readonly _fields;
+    private _initialValue;
+    private _optIn?;
+    private _optOut?;
+    constructor(args: ObjectField.ConstructorArgs);
+    get events$(): Observable<FieldModel.Event>;
+    get initialValue(): ObjectField.Value | undefined;
+    get exists(): boolean;
+    get isNew(): boolean;
+    get valid(): boolean;
+    get error(): FieldValidator.Error | undefined;
+    get errors(): FieldValidator.Error[];
+    get content(): Readonly<ObjectField.Fields>;
+    get fields(): readonly ObjectField.FieldsValues[];
+    get hasValue(): boolean;
+    get value(): ObjectField.Value;
+    set value(value: ObjectField.Value);
+    get modified(): boolean;
+    get changed(): boolean;
+    get preview(): ObjectField.Preview;
+    get optedOut(): boolean;
+    get canOptOut(): boolean;
+    optIn(): void;
+    optOut(): void;
+    get shouldFocus(): boolean;
+    didFocus(): boolean;
+    getString(key: string | undefined): string | undefined;
+    reset(initialValue?: ObjectField.Value | null): void;
+    clone(): ObjectField;
+    private raiseEvent;
+    static forSchema(schema: Schema.ObjectField): ObjectField;
+}
+export declare namespace ObjectField {
+    type ConstructorArgs = {
+        eventBus: EventBus;
+        schema: Schema.ObjectField;
+        id: string;
+        name: string;
+        publishedValue?: Value;
+        initialValue?: Value;
+        required: boolean;
+    };
+    type Value = Schema.Field.Data<Schema.ObjectField>;
+    type Fields = Record<string, FieldsValues>;
+    type FieldsValues = Field | FieldList | ObjectField;
+    type Data = Record<string, Schema.Field.Data<Schema.ObjectField.Content.Type>>;
+    type Preview = {
+        title: Field<Schema.TextField | Schema.RichTextField>;
+        subtitle?: Field<Schema.TextField | Schema.RichTextField>;
+        visual?: Field<Schema.AssetField>;
+    };
+    interface Event extends EventBus.Event<'ObjectField', Event.Type> {
+        field: ObjectField;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/ui/fields/ObjectField.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectField = void 0;
+const rxjs_1 = require("rxjs");
+const services_1 = require("../../services");
+const utils_1 = require("../../utils");
+const Field_1 = require("./Field");
+const FieldList_1 = require("./FieldList");
+const FieldModel_1 = require("./FieldModel");
+const FieldValidator_1 = require("./FieldValidator");
+// class
+class ObjectField {
+    constructor(args) {
+        // initialize instance variables
+        this.eventBus = args.eventBus;
+        this.schema = args.schema;
+        this._content = deserializeFields(args);
+        this._fields = Object.values(this._content);
+        this.id = args.id;
+        this.name = args.name;
+        this.required = args.required;
+        this.publishedValue = args.publishedValue;
+        this._initialValue = args.initialValue;
+    }
+    get events$() {
+        return this.eventBus.events$.pipe((0, rxjs_1.filter)(e => (ObjectField.Event.filter(e) && e.field === this)
+            || (FieldModel_1.FieldModel.Event.filter(e) && this._fields.includes(e.field))));
+    }
+    get initialValue() {
+        return this._initialValue;
+    }
+    get exists() {
+        const { _initialValue, _optIn = false, _optOut = false, schema: { required } } = this;
+        return (_initialValue !== undefined && !_optOut) || required || _optIn;
+    }
+    get isNew() {
+        const { exists, _initialValue } = this;
+        return exists && (_initialValue === undefined
+            || utils_1.Value.equals(_initialValue.value, {}));
+    }
+    get valid() {
+        return this.errors.length === 0;
+    }
+    get error() {
+        return FieldValidator_1.FieldValidator.Error.mostRelevant(this.errors);
+    }
+    get errors() {
+        // no errors if not existing and not required
+        const { required, exists, _fields } = this;
+        if (!required && !exists) {
+            return [];
+        }
+        // otherwise return errors
+        else {
+            return _fields.flatMap(field => field.errors);
+        }
+    }
+    get content() {
+        return this._content;
+    }
+    get fields() {
+        return this._fields;
+    }
+    get hasValue() {
+        return this._fields.some(field => field.hasValue);
+    }
+    get value() {
+        // reduce value from fields
+        return {
+            type: 'object',
+            value: this._fields.reduce((values, { id, value }) => {
+                // bind value if it's set
+                if (value !== undefined) {
+                    values[id] = value;
+                }
+                // keep reducing
+                return values;
+            }, {})
+        };
+    }
+    set value(value) {
+        var _a;
+        // update values
+        const values = (_a = value.value) !== null && _a !== void 0 ? _a : {};
+        Object.entries(this._content).forEach(([key, field]) => {
+            if (field instanceof ObjectField) {
+                field.value = values[key];
+            }
+            else if (field instanceof FieldList_1.FieldList) {
+                field.value = values[key];
+            }
+            else {
+                field.value = values[key];
+            }
+        });
+    }
+    get modified() {
+        // modified if opted in/our
+        const { required, exists, _optIn, _optOut } = this;
+        if (_optIn || _optOut) {
+            return true;
+        }
+        // don't check if it isn't created (assume not modified)
+        else if (!required && !exists) {
+            return false;
+        }
+        // or compare values (deep comparison)
+        else {
+            return !utils_1.Value.equals(this.value, this._initialValue);
+        }
+    }
+    get changed() {
+        const { value, publishedValue } = this;
+        return !utils_1.Value.equals(value, publishedValue);
+    }
+    get preview() {
+        // determine fields to lookup
+        const { schema: { preview: previewSpec }, content } = this;
+        // return preview
+        return {
+            title: content[previewSpec.title],
+            subtitle: previewSpec.subtitle ? content[previewSpec.subtitle] : undefined,
+            visual: previewSpec.visual ? content[previewSpec.visual] : undefined
+        };
+    }
+    get optedOut() {
+        var _a;
+        return (_a = this._optOut) !== null && _a !== void 0 ? _a : false;
+    }
+    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._optOut = false;
+        this.raiseEvent('changed');
+    }
+    optOut() {
+        // skip if required
+        const { schema } = this;
+        if (schema.required) {
+            return;
+        }
+        // set opt-out flag
+        this._optIn = false;
+        this._optOut = true;
+        this.reset(null);
+    }
+    get shouldFocus() {
+        return false;
+    }
+    didFocus() {
+        return false;
+    }
+    getString(key) {
+        // skip if key isn't defined
+        if (!key) {
+            return undefined;
+        }
+        // skip if item is missing
+        const { content } = this;
+        const field = content[key];
+        if (!field) {
+            return undefined;
+        }
+        // return value based on type
+        const { value: data } = field;
+        switch (data === null || data === void 0 ? void 0 : data.type) {
+            case 'text':
+            case 'enum':
+                return data.value;
+            default:
+                return undefined;
+        }
+    }
+    reset(initialValue) {
+        var _a;
+        if (initialValue !== undefined) {
+            this._initialValue = initialValue !== null && initialValue !== void 0 ? initialValue : undefined;
+            // re-bind new initial values
+            const values = (_a = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _a !== void 0 ? _a : {};
+            Object.entries(this._content).forEach(([key, field]) => {
+                var _a, _b, _c;
+                if (field instanceof ObjectField) {
+                    field.reset((_a = values[key]) !== null && _a !== void 0 ? _a : null);
+                }
+                else if (field instanceof FieldList_1.FieldList) {
+                    field.reset((_b = values[key]) !== null && _b !== void 0 ? _b : null);
+                }
+                else {
+                    field.reset((_c = values[key]) !== null && _c !== void 0 ? _c : null);
+                }
+            });
+        }
+        //  reset each field if there's no initial value
+        else {
+            this._fields.forEach(field => field.reset());
+        }
+        // raise final change
+        this.raiseEvent('changed');
+    }
+    clone() {
+        return new ObjectField({
+            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(ObjectField.Event.create({ type, field: this }));
+    }
+    static forSchema(schema) {
+        return new ObjectField({
+            eventBus: new services_1.EventBus(),
+            schema,
+            id: utils_1.Value.uuid(),
+            name: schema.name,
+            required: true
+        });
+    }
+}
+exports.ObjectField = ObjectField;
+// extension
+(function (ObjectField) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'ObjectField';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return services_1.EventBus.createEvent(Object.assign({ domain: 'ObjectField' }, event));
+        }
+        Event.create = create;
+    })(Event = ObjectField.Event || (ObjectField.Event = {}));
+})(ObjectField || (exports.ObjectField = ObjectField = {}));
+function deserializeFields({ eventBus, schema, initialValue }) {
+    var _a;
+    // TODO: should we add a published value?!
+    // create fields for each object entry
+    const initialValues = (_a = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _a !== void 0 ? _a : {};
+    return Object.entries(schema.content).reduce((fields, [id, fieldSchemaMaybe]) => {
+        // create field
+        const fieldSchema = fieldSchemaMaybe.unwrap();
+        switch (fieldSchema.type) {
+            // map simple fields
+            case 'text':
+            case 'richtext':
+            case 'enum':
+            case 'boolean':
+            case 'link':
+            case 'asset':
+                fields[id] = new Field_1.Field({
+                    eventBus,
+                    schema: fieldSchema,
+                    id,
+                    name: fieldSchema.name,
+                    initialValue: initialValues[id],
+                    required: fieldSchema.required
+                });
+                break;
+            // map lists
+            case 'list':
+                fields[id] = new FieldList_1.FieldList({
+                    eventBus,
+                    schema: fieldSchema,
+                    id,
+                    name: fieldSchema.name,
+                    initialValue: initialValues[id],
+                    required: fieldSchema.required
+                });
+                break;
+        }
+        // keep reducing
+        return fields;
+    }, {});
+}

package/dist/ui/fields/errors.json

@@ -0,0 +1,44 @@
+{
+    "en": {
+        "required": "${label} is required",
+        "minLength": "${label} needs least ${minLength} characters",
+        "maxLength": "${label} cannot exceed ${maxLength} characters",
+        "empty": "${label} is required",
+        "exact": "Please enter \"${exact}\"",
+        "email": "${label} is an invalid format",
+        "phone": "${label} is an invalid format",
+        "url": "${label} is not a valid URL",
+        "uri": "${label} must be a URL, email, or phone number",
+        "regex": "${label} is not valid",
+        "regex.password": "Needs at least 1 digit, uppercase, lowercase, and special character",
+        "array.min": "${label} needs at least ${min} elements",
+        "array.max": "${label} cannot exceed ${max} elements",
+        "date": "${label} is not a valid date",
+        "date.minDate": "${label} cannot be before ${minDate}",
+        "date.maxDate": "${label} cannot be after ${maxDate}",
+        "timestamp": "${label} is not a valid date/time",
+        "timestamp.minTime": "${label} cannot be before ${minTime}",
+        "timestamp.maxTime": "${label} cannot be after ${maxTime}"
+    },
+    "fr": {
+        "required": "${label} is required",
+        "minLength": "${label} needs least ${minLength} characters",
+        "maxLength": "${label} cannot exceed ${maxLength} characters",
+        "empty": "${label} is required",
+        "exact": "Please enter \"${exact}\"",
+        "email": "${label} is an invalid format",
+        "phone": "${label} is an invalid format",
+        "url": "${label} is not a valid URL",
+        "uri": "${label} must be a URL, email, or phone number",
+        "regex": "${label} is not valid",
+        "regex.password": "Needs at least 1 digit, uppercase, lowercase, and special character",
+        "array.min": "${label} needs at least ${min} elements",
+        "array.max": "${label} cannot exceed ${max} elements",
+        "date": "${label} is not a valid date",
+        "date.minDate": "${label} cannot be before ${minDate}",
+        "date.maxDate": "${label} cannot be after ${maxDate}",
+        "timestamp": "${label} is not a valid date/time",
+        "timestamp.minTime": "${label} cannot be before ${minTime}",
+        "timestamp.maxTime": "${label} cannot be after ${maxTime}"
+    }
+}

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

@@ -0,0 +1,7 @@
+export * from './Field';
+export * from './FieldList';
+export * from './FieldListValidator';
+export * from './FieldModel';
+export * from './FieldSerializer';
+export * from './FieldValidator';
+export * from './ObjectField';

package/dist/ui/fields/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("./Field"), exports);
+__exportStar(require("./FieldList"), exports);
+__exportStar(require("./FieldListValidator"), exports);
+__exportStar(require("./FieldModel"), exports);
+__exportStar(require("./FieldSerializer"), exports);
+__exportStar(require("./FieldValidator"), exports);
+__exportStar(require("./ObjectField"), exports);

package/dist/ui/fields/validators/AssetValidator.d.ts

@@ -0,0 +1,9 @@
+import type { AssetField } from '../../../schema/field/base/AssetField';
+import { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class AssetValidator {
+    readonly schema: AssetField;
+    constructor(schema: AssetField);
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawValue: any): FieldValidator.Error[];
+}

package/dist/ui/fields/validators/AssetValidator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetValidator = void 0;
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class AssetValidator {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawValue) {
+        // handle case where unset (fail if not optional)
+        const data = rawValue;
+        if (!data || !data.value) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value: data })]
+                : [];
+        }
+        // return errors
+        return [];
+    }
+}
+exports.AssetValidator = AssetValidator;

package/dist/ui/fields/validators/DateValidator.d.ts

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

package/dist/ui/fields/validators/DateValidator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateValidator = void 0;
+const DateString_1 = require("../../../types/DateString");
+const ValidatorHelper_1 = require("./ValidatorHelper");
+// class
+class DateValidator {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    filter(errors, level) {
+        return ValidatorHelper_1.ValidatorHelper.filterErrors(errors, level);
+    }
+    validate(field, rawData) {
+        // handle case where unset (fail if not optional)
+        const data = rawData;
+        if (!data || !data.value) {
+            return field.required
+                ? [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'required', value: data })]
+                : [];
+        }
+        // fail if invalid format
+        const { value } = data;
+        if (!DateString_1.DateString.filter(value)) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'date', critical: true, value })];
+        }
+        // or fail if minDate is violated
+        const { minDate, maxDate } = this.schema;
+        if (minDate && DateString_1.DateString.isBefore(value, minDate)) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'date.minDate', critical: true, value })];
+        }
+        else if (maxDate && DateString_1.DateString.isBefore(value, maxDate)) {
+            return [ValidatorHelper_1.ValidatorHelper.createError({ field, id: 'date.maxDate', critical: true, value })];
+        }
+        // otherwise, transform errors
+        else {
+            return [];
+        }
+    }
+}
+exports.DateValidator = DateValidator;

package/dist/ui/fields/validators/EnumValidator.d.ts

@@ -0,0 +1,10 @@
+import type { EnumField } from '../../../schema/field/base/EnumField';
+import type { Field as FieldModel } from '../Field';
+import type { FieldValidator } from '../FieldValidator';
+export declare class EnumValidator {
+    readonly schema: EnumField;
+    private readonly _zod;
+    constructor(schema: EnumField, field: FieldModel);
+    filter(errors: ReadonlyArray<FieldValidator.Error>, level: FieldValidator.Error.Level): ReadonlyArray<FieldValidator.Error>;
+    validate(field: FieldModel, rawData: any): FieldValidator.Error[];
+}