@nascentdigital/funnel-core 4.4.4

package/dist/schema/field/base/DynamicPagesField.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicPagesField = void 0;
+const index_1 = require("../index");
+// class
+class DynamicPagesField extends index_1.Field {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(args);
+        this.type = 'dynamic.pages';
+        // initialize instance variables
+        this.types = (_a = args.types) !== null && _a !== void 0 ? _a : 'all';
+        this.size = args.size;
+    }
+    get schema() {
+        return {
+            types: this.types,
+            size: this.size
+        };
+    }
+    modify(args) {
+        return new DynamicPagesField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, types: this.types, size: this.size }, args));
+    }
+}
+exports.DynamicPagesField = DynamicPagesField;
+// extension
+(function (DynamicPagesField) {
+    let Value;
+    (function (Value) {
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'dynamic.pages',
+                value
+            };
+        }
+        Value.toData = toData;
+        function coerceData(value) {
+            return value === undefined
+                ? undefined
+                : toData(value);
+        }
+        Value.coerceData = coerceData;
+    })(Value = DynamicPagesField.Value || (DynamicPagesField.Value = {}));
+})(DynamicPagesField || (exports.DynamicPagesField = DynamicPagesField = {}));

package/dist/schema/field/base/EmbeddedVideoField.d.ts

@@ -0,0 +1,45 @@
+import { Field } from '../index';
+export declare class EmbeddedVideoField extends Field<EmbeddedVideoField> {
+    readonly type: "embedded.video";
+    readonly allowMuting: boolean;
+    constructor({ allowMuting, ...args }: EmbeddedVideoField.ConstructorArgs);
+    modify(args: EmbeddedVideoField.ModifyArgs): EmbeddedVideoField;
+}
+export declare namespace EmbeddedVideoField {
+    type Source = 'youtube' | 'vimeo';
+    namespace Source {
+        const values: ReadonlyArray<Source>;
+        function filter(value: any): value is Source;
+    }
+    type Value = Value.Youtube | Value.Vimeo;
+    namespace Value {
+        type Youtube = {
+            type: 'youtube';
+            videoId: string;
+            thumbUrl: string;
+            muted?: boolean;
+        };
+        namespace Youtube {
+            function filter(data: Value): data is Youtube;
+        }
+        type Vimeo = {
+            type: 'vimeo';
+            videoId: string;
+            thumbUrl: string;
+            hash?: string;
+            muted?: boolean;
+        };
+        namespace Vimeo {
+            function filter(data: Value): data is Vimeo;
+        }
+        function filter(value: any): value is Value;
+        function fromData(data: Field.Data<EmbeddedVideoField>): Value;
+        function toData(value: Value): Field.Data<EmbeddedVideoField>;
+        function fromUrl(url?: URL): Value | undefined;
+        function toUrl(value: Value, type?: 'watch' | 'embed'): URL;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        allowMuting?: boolean;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}

package/dist/schema/field/base/EmbeddedVideoField.js

@@ -0,0 +1,176 @@
+"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.EmbeddedVideoField = void 0;
+const index_1 = require("../index");
+// class
+class EmbeddedVideoField extends index_1.Field {
+    constructor(_a) {
+        var { allowMuting = true } = _a, args = __rest(_a, ["allowMuting"]);
+        // construct base
+        super(args);
+        this.type = 'embedded.video';
+        // initialize instance variables
+        this.allowMuting = allowMuting;
+    }
+    modify(args) {
+        return new EmbeddedVideoField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, allowMuting: this.allowMuting }, args));
+    }
+}
+exports.EmbeddedVideoField = EmbeddedVideoField;
+// extension
+(function (EmbeddedVideoField) {
+    let Source;
+    (function (Source) {
+        // values
+        Source.values = [
+            'youtube', 'vimeo'
+        ];
+        // methods
+        function filter(value) {
+            return !!value
+                && typeof value === 'string'
+                && Source.values.includes(value);
+        }
+        Source.filter = filter;
+    })(Source = EmbeddedVideoField.Source || (EmbeddedVideoField.Source = {}));
+    let Value;
+    (function (Value) {
+        let Youtube;
+        (function (Youtube) {
+            // guards
+            function filter(data) {
+                return data.type === 'youtube';
+            }
+            Youtube.filter = filter;
+        })(Youtube = Value.Youtube || (Value.Youtube = {}));
+        let Vimeo;
+        (function (Vimeo) {
+            // guard
+            function filter(data) {
+                return data.type === 'vimeo';
+            }
+            Vimeo.filter = filter;
+        })(Vimeo = Value.Vimeo || (Value.Vimeo = {}));
+        // guard
+        function filter(value) {
+            return !!value
+                && typeof value === 'object'
+                && !Array.isArray(value)
+                && 'type' in value && !!value.type && typeof value.type === 'string' && Source.filter(value.type)
+                && 'videoId' in value && !!value.videoId && typeof value.videoId === 'string';
+        }
+        Value.filter = filter;
+        // serialization
+        function fromData(data) {
+            return data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'embedded.video',
+                value
+            };
+        }
+        Value.toData = toData;
+        function fromUrl(url) {
+            var _a, _b, _c, _d, _e, _f;
+            // skip if there's no url
+            if (!url) {
+                return undefined;
+            }
+            // evaluate url
+            const { hostname, pathname, searchParams } = url;
+            const pathComponents = pathname.substring(1).split('/');
+            switch (hostname.toLowerCase()) {
+                // youtube
+                case 'youtube.com':
+                case 'www.youtube.com':
+                case 'm.youtube.com': {
+                    const action = (_b = (_a = pathComponents[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
+                    if (action === 'embed' && pathComponents.length > 1) {
+                        return {
+                            type: 'youtube',
+                            videoId: pathComponents[1],
+                            thumbUrl: ''
+                        };
+                    }
+                    else if (action === 'watch') {
+                        const videoId = searchParams.get('v');
+                        return videoId
+                            ?
+                                {
+                                    type: 'youtube',
+                                    videoId,
+                                    thumbUrl: ''
+                                }
+                            : undefined;
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                // vimeo
+                case 'vimeo.com':
+                case 'www.vimeo.com': {
+                    const [videoId] = pathComponents;
+                    const hash = (_c = searchParams.get('h')) !== null && _c !== void 0 ? _c : undefined;
+                    return videoId
+                        ?
+                            {
+                                type: 'vimeo',
+                                videoId,
+                                thumbUrl: '',
+                                hash
+                            }
+                        : undefined;
+                }
+                case 'player.vimeo.com': {
+                    const action = (_e = (_d = pathComponents[0]) === null || _d === void 0 ? void 0 : _d.toLowerCase()) !== null && _e !== void 0 ? _e : '';
+                    if (action === 'video' && pathComponents.length > 1) {
+                        const hash = (_f = searchParams.get('h')) !== null && _f !== void 0 ? _f : undefined;
+                        return {
+                            type: 'vimeo',
+                            videoId: pathComponents[1],
+                            thumbUrl: '',
+                            hash
+                        };
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                // or fail
+                default:
+                    return undefined;
+            }
+        }
+        Value.fromUrl = fromUrl;
+        function toUrl(value, type = 'embed') {
+            switch (value.type) {
+                case 'youtube':
+                    return new URL(type === 'embed'
+                        ? `https://www.youtube.com/embed/${value.videoId}`
+                        : `https://www.youtube.com/watch?v=${encodeURI(value.videoId)}`);
+                case 'vimeo': {
+                    const url = new URL(`https://player.vimeo.com/video/${value.videoId}`);
+                    if (value.hash) {
+                        url.searchParams.append('h', value.hash);
+                    }
+                    return url;
+                }
+            }
+        }
+        Value.toUrl = toUrl;
+    })(Value = EmbeddedVideoField.Value || (EmbeddedVideoField.Value = {}));
+})(EmbeddedVideoField || (exports.EmbeddedVideoField = EmbeddedVideoField = {}));

package/dist/schema/field/base/EnumField.d.ts

@@ -0,0 +1,40 @@
+import { StringKeyOf } from 'type-fest';
+import { Field } from '../index';
+export declare class EnumField<TOptions extends EnumField.Options = EnumField.Options> extends Field<EnumField<TOptions>> {
+    readonly type: "enum";
+    readonly semantics: EnumField.Semantics;
+    readonly options: TOptions;
+    readonly defaultOption?: StringKeyOf<TOptions>;
+    constructor(args: EnumField.ConstructorArgs<TOptions>);
+    get enum(): EnumField.Enum<TOptions>[];
+    modify({ options, ...args }: EnumField.ModifyArgs<TOptions>): EnumField<TOptions>;
+    updateOptions(options: Partial<TOptions>): EnumField<TOptions>;
+    removeOption<TKey extends StringKeyOf<TOptions>>(key: TKey): EnumField<TOptions>;
+    removeOptions<TKey extends StringKeyOf<TOptions>>(...keys: ReadonlyArray<TKey>): EnumField<TOptions>;
+    keepOptions<TKey extends StringKeyOf<TOptions>>(...keys: ReadonlyArray<TKey>): EnumField<TOptions>;
+    isValidOption<TKey extends StringKeyOf<TOptions>>(key: TKey | undefined): boolean;
+    setDefault<TKey extends StringKeyOf<TOptions>>(key: TKey | undefined): EnumField<TOptions>;
+}
+export declare namespace EnumField {
+    type Value<TField extends EnumField> = StringKeyOf<TField['options']>;
+    namespace Value {
+        function fromData<TField extends EnumField>(data: Field.Data<TField> | undefined): Value<TField>;
+        function toData<TField extends EnumField>(value: Value<TField>): Field.Data<EnumField>;
+    }
+    type ConstructorArgs<TOptions extends Options> = Field.ConstructorArgs & {
+        semantics?: Semantics;
+        options: TOptions;
+        defaultOption?: StringKeyOf<TOptions>;
+    };
+    type Enum<TOptions extends Options> = StringKeyOf<TOptions>;
+    type Options<TOption extends string = string> = Record<TOption, Readonly<Option>>;
+    type Option = {
+        name: string;
+        hint?: string;
+        hidden?: true;
+    };
+    type Semantics = 'dropdown' | 'radio' | 'segmented';
+    type ModifyArgs<TOptions extends Options> = Omit<Partial<ConstructorArgs<TOptions>>, 'required' | 'options'> & {
+        options?: Partial<TOptions>;
+    };
+}

package/dist/schema/field/base/EnumField.js

@@ -0,0 +1,131 @@
+"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.EnumField = void 0;
+const index_1 = require("../index");
+// class
+class EnumField extends index_1.Field {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(args);
+        this.type = 'enum';
+        // initialize instance variables
+        this.semantics = (_a = args.semantics) !== null && _a !== void 0 ? _a : 'dropdown';
+        this.options = args.options;
+        this.defaultOption = args.defaultOption;
+    }
+    get enum() {
+        return Object.keys(this.options);
+    }
+    modify(_a) {
+        var _b;
+        var { options } = _a, args = __rest(_a, ["options"]);
+        return new EnumField(Object.assign({ semantics: this.semantics, name: this.name, hint: this.hint, description: this.description, required: this.required, options: (_b = options) !== null && _b !== void 0 ? _b : this.options, defaultOption: this.defaultOption }, args));
+    }
+    updateOptions(options) {
+        return new EnumField({
+            semantics: this.semantics,
+            name: this.name,
+            hint: this.hint,
+            description: this.description,
+            required: this.required,
+            options: Object.assign(Object.assign({}, this.options), options),
+            defaultOption: this.defaultOption
+        });
+    }
+    removeOption(key) {
+        return this.removeOptions(key);
+    }
+    removeOptions(...keys) {
+        // prune options
+        const prunedOptions = Object.assign({}, this.options);
+        keys.forEach(key => {
+            delete prunedOptions[key];
+        });
+        // create new enum
+        const { defaultOption } = this;
+        return new EnumField({
+            semantics: this.semantics,
+            name: this.name,
+            hint: this.hint,
+            description: this.description,
+            required: this.required,
+            options: prunedOptions,
+            defaultOption: defaultOption === undefined || defaultOption in prunedOptions
+                ? defaultOption
+                : Object.keys(prunedOptions)[0]
+        });
+    }
+    keepOptions(...keys) {
+        // prune options
+        const { defaultOption, options: allOptions } = this;
+        const prunedOptions = Object.entries(allOptions)
+            .reduce((options, [key, option]) => {
+            // add option if it's in the set
+            if (keys.includes(key)) {
+                options[key] = option;
+            }
+            // keep reducing
+            return options;
+        }, {});
+        // create new enum
+        return new EnumField({
+            semantics: this.semantics,
+            name: this.name,
+            hint: this.hint,
+            description: this.description,
+            required: this.required,
+            options: prunedOptions,
+            defaultOption: defaultOption === undefined || defaultOption in prunedOptions
+                ? defaultOption
+                : Object.keys(prunedOptions)[0]
+        });
+    }
+    isValidOption(key) {
+        if (!key) {
+            return false;
+        }
+        return key in this.options;
+    }
+    setDefault(key) {
+        return new EnumField({
+            semantics: this.semantics,
+            name: this.name,
+            hint: this.hint,
+            description: this.description,
+            required: this.required,
+            options: this.options,
+            defaultOption: key
+        });
+    }
+}
+exports.EnumField = EnumField;
+// extension
+(function (EnumField) {
+    let Value;
+    (function (Value) {
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'enum',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = EnumField.Value || (EnumField.Value = {}));
+})(EnumField || (exports.EnumField = EnumField = {}));

package/dist/schema/field/base/FormField.d.ts

@@ -0,0 +1,25 @@
+import type { Ordinal } from '../../../types/Ordinal';
+import { Field } from '../index';
+export declare class FormField extends Field<FormField> {
+    readonly type: "form";
+    readonly formId: string;
+    constructor({ formId, ...args }: FormField.ConstructorArgs);
+    modify(args: FormField.ModifyArgs): FormField;
+}
+export declare namespace FormField {
+    type FieldConfig = Pick<Field.ConstructorArgs, 'name' | 'description' | 'hint'> & {
+        order: Ordinal.Id;
+    };
+    type Value = {
+        formId: string;
+        fields: Record<string, FieldConfig>;
+    };
+    namespace Value {
+        function fromData(data: Field.Data<FormField> | undefined): Value | undefined;
+        function toData(value: Value): Field.Data<FormField>;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        formId: string;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}

package/dist/schema/field/base/FormField.js

@@ -0,0 +1,48 @@
+"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.FormField = void 0;
+const index_1 = require("../index");
+// class
+class FormField extends index_1.Field {
+    constructor(_a) {
+        var { formId } = _a, args = __rest(_a, ["formId"]);
+        // construct base
+        super(args);
+        this.type = 'form';
+        // initialize instance variables
+        this.formId = formId;
+    }
+    modify(args) {
+        return new FormField(Object.assign({ formId: this.formId, name: this.name, hint: this.hint, description: this.description, required: this.required }, args));
+    }
+}
+exports.FormField = FormField;
+// extension
+(function (FormField) {
+    let Value;
+    (function (Value) {
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'form',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = FormField.Value || (FormField.Value = {}));
+})(FormField || (exports.FormField = FormField = {}));

package/dist/schema/field/base/LinkField.d.ts

@@ -0,0 +1,103 @@
+import { MimeType } from '../../../ui';
+import { Page } from '../../Page';
+import { Field, AssetField, PageField } from '../index';
+export declare class LinkField extends Field<LinkField> {
+    readonly type: "link";
+    readonly allowExternal?: boolean;
+    readonly allowEmail?: boolean;
+    readonly allowPhone?: boolean;
+    readonly internalOptions?: LinkField.InternalArgs;
+    readonly fileOptions?: LinkField.FileArgs;
+    constructor(args: LinkField.ConstructorArgs);
+    get allowInternal(): boolean;
+    get allowFile(): boolean;
+    modify(args: LinkField.ModifyArgs): LinkField;
+}
+export declare namespace LinkField {
+    type LinkType = 'internal' | 'external' | 'email' | 'phone' | 'file';
+    namespace LinkType {
+        const values: ReadonlyArray<LinkType>;
+        function filter(value: any): value is LinkType;
+    }
+    type Value = Value.Internal | Value.External | Value.Email | Value.Phone | Value.File;
+    namespace Value {
+        type Type = Value['type'];
+        type Internal = {
+            type: 'internal';
+            label: string;
+            page: Field.Data<PageField.Link>;
+        };
+        namespace Internal {
+            function filter(data: Value): data is Internal;
+            function fromData(data: Field.Data<LinkField> | undefined): Internal;
+        }
+        type External = {
+            type: 'external';
+            label: string;
+            url: string;
+        };
+        namespace External {
+            function filter(data: Value): data is External;
+            function fromData(data: Field.Data<LinkField> | undefined): External;
+        }
+        type Email = {
+            type: 'email';
+            label: string;
+            email: string;
+            subject?: string;
+        };
+        namespace Email {
+            function filter(data: Value): data is Email;
+            function fromData(data: Field.Data<LinkField> | undefined): Email;
+        }
+        type Phone = {
+            type: 'phone';
+            label: string;
+            number: string;
+        };
+        namespace Phone {
+            function filter(data: Value): data is Phone;
+            function fromData(data: Field.Data<LinkField> | undefined): Phone;
+        }
+        type File = {
+            type: 'file';
+            label: string;
+            file: AssetField.Value;
+            action: FileLinkAction;
+        };
+        namespace File {
+            function filter(data: Value): data is File;
+        }
+        function fromData(data: Field.Data<LinkField>): Value;
+        function toData(value: Value): Field.Data<LinkField>;
+        function toUrl(value: Exclude<Value, Value.Internal>): string;
+    }
+    type LinkedValue = LinkedValue.Internal | Value.External | Value.Email | Value.Phone | Value.File;
+    namespace LinkedValue {
+        type Internal = Omit<Value.Internal, 'page'> & {
+            page: Field.LinkedData<PageField.Link>;
+        };
+    }
+    type ConstructorArgs<TPage extends string = string> = Field.ConstructorArgs & Partial<ExternalArgs> & Partial<EmailArgs> & Partial<PhoneArgs> & {
+        internal?: InternalArgs<TPage>;
+        file?: FileArgs;
+    };
+    type FileLinkAction = 'view' | 'download';
+    type FileArgs = {
+        mimeTypes: ReadonlyArray<MimeType>;
+        action: FileLinkAction;
+    };
+    type InternalArgs<TPage extends string = Page.Type> = {
+        pageTypes: ReadonlyArray<TPage> | 'all';
+    };
+    type ExternalArgs = {
+        allowExternal: boolean;
+    };
+    type EmailArgs = {
+        allowEmail: boolean;
+    };
+    type PhoneArgs = {
+        allowPhone: boolean;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}