@nascentdigital/funnel-core 4.4.4

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkField = void 0;
+const errors_1 = require("../../../errors");
+const Page_1 = require("../../Page");
+const index_1 = require("../index");
+// class
+class LinkField extends index_1.Field {
+    constructor(args) {
+        // construct base
+        super(args);
+        this.type = 'link';
+        // initialize instance variables
+        this.allowExternal = args.allowExternal;
+        this.allowEmail = args.allowEmail;
+        this.allowPhone = args.allowPhone;
+        this.internalOptions = args.internal;
+        this.fileOptions = args.file;
+    }
+    get allowInternal() {
+        return this.internalOptions !== undefined;
+    }
+    get allowFile() {
+        return this.fileOptions !== undefined;
+    }
+    modify(args) {
+        return new LinkField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, allowExternal: this.allowExternal, allowEmail: this.allowEmail, allowPhone: this.allowPhone, internal: this.internalOptions, file: this.fileOptions }, args));
+    }
+}
+exports.LinkField = LinkField;
+// extension
+(function (LinkField) {
+    let LinkType;
+    (function (LinkType) {
+        // values
+        LinkType.values = [
+            'internal', 'external', 'email', 'phone', 'file'
+        ];
+        // methods
+        function filter(value) {
+            return !!value
+                && typeof value === 'string'
+                && LinkType.values.includes(value);
+        }
+        LinkType.filter = filter;
+    })(LinkType = LinkField.LinkType || (LinkField.LinkType = {}));
+    let Value;
+    (function (Value) {
+        let Internal;
+        (function (Internal) {
+            // guards
+            function filter(data) {
+                return data.type === 'internal';
+            }
+            Internal.filter = filter;
+            function fromData(data) {
+                // create default if no data is found
+                if (!data || !data.value) {
+                    return {
+                        type: 'internal',
+                        page: {
+                            __ref: 'page',
+                            type: 'page',
+                            value: {
+                                scope: 'link',
+                                id: Page_1.Page.Id.draft,
+                                type: Page_1.Page.Type.unknown
+                            }
+                        },
+                        label: ''
+                    };
+                }
+                // or throw if value is not expected type
+                else if (data.value.type !== 'internal') {
+                    throw new errors_1.ArgumentError(`Expected "internal" link but found "${data.value.type}"`);
+                }
+                // otherwise, return value
+                else {
+                    return data.value;
+                }
+            }
+            Internal.fromData = fromData;
+        })(Internal = Value.Internal || (Value.Internal = {}));
+        let External;
+        (function (External) {
+            // guard
+            function filter(data) {
+                return data.type === 'external';
+            }
+            External.filter = filter;
+            function fromData(data) {
+                // create default if no data is found
+                if (!data || !data.value) {
+                    return {
+                        type: 'external',
+                        url: '',
+                        label: ''
+                    };
+                }
+                // or throw if value is not expected type
+                else if (data.value.type !== 'external') {
+                    throw new errors_1.ArgumentError(`Expected "external" link but found "${data.value.type}"`);
+                }
+                // otherwise, return value
+                else {
+                    return data.value;
+                }
+            }
+            External.fromData = fromData;
+        })(External = Value.External || (Value.External = {}));
+        let Email;
+        (function (Email) {
+            // guard
+            function filter(data) {
+                return data.type === 'email';
+            }
+            Email.filter = filter;
+            function fromData(data) {
+                // create default if no data is found
+                if (!data || !data.value) {
+                    return {
+                        type: 'email',
+                        label: '',
+                        email: '',
+                        subject: ''
+                    };
+                }
+                // or throw if value is not expected type
+                else if (data.value.type !== 'email') {
+                    throw new errors_1.ArgumentError(`Expected "email" link but found "${data.value.type}"`);
+                }
+                // otherwise, return value
+                else {
+                    return data.value;
+                }
+            }
+            Email.fromData = fromData;
+        })(Email = Value.Email || (Value.Email = {}));
+        let Phone;
+        (function (Phone) {
+            // guard
+            function filter(data) {
+                return data.type === 'phone';
+            }
+            Phone.filter = filter;
+            function fromData(data) {
+                // create default if no data is found
+                if (!data || !data.value) {
+                    return {
+                        type: 'phone',
+                        label: '',
+                        number: ''
+                    };
+                }
+                // or throw if value is not expected type
+                else if (data.value.type !== 'phone') {
+                    throw new errors_1.ArgumentError(`Expected "phone" link but found "${data.value.type}"`);
+                }
+                // otherwise, return value
+                else {
+                    return data.value;
+                }
+            }
+            Phone.fromData = fromData;
+        })(Phone = Value.Phone || (Value.Phone = {}));
+        let File;
+        (function (File) {
+            function filter(data) {
+                return data.type === 'file';
+            }
+            File.filter = filter;
+        })(File = Value.File || (Value.File = {}));
+        // serialization
+        function fromData(data) {
+            return data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                type: 'link',
+                value
+            };
+        }
+        Value.toData = toData;
+        function toUrl(value) {
+            switch (value.type) {
+                case 'external':
+                    return value.url;
+                case 'email':
+                    return value.subject
+                        ? `mailto:${value.email}?subject=${encodeURIComponent(value.subject)}`
+                        : `mailto:${value.email}`;
+                case 'phone':
+                    return `tel:${value.number}`;
+                case 'file':
+                    return '#';
+            }
+        }
+        Value.toUrl = toUrl;
+    })(Value = LinkField.Value || (LinkField.Value = {}));
+})(LinkField || (exports.LinkField = LinkField = {}));

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

@@ -0,0 +1,46 @@
+import { Page } from '../../Page';
+import { Tag } from '../../Tag';
+import { Field } from '../index';
+export declare class PageField<TScope extends PageField.Scope = PageField.Scope> extends Field<PageField<TScope>> {
+    readonly type: "page";
+    readonly scope: TScope;
+    readonly pageTypes: ReadonlyArray<Page.Type> | 'all';
+    readonly tags: ReadonlyArray<Tag>;
+    constructor(args: PageField.ConstructorArgs<TScope>);
+    modify(args: PageField.ModifyArgs): PageField<TScope>;
+}
+export declare namespace PageField {
+    type Link = PageField<'link'>;
+    type Preview = PageField<'preview'>;
+    type Full = PageField<'full'>;
+    type Value<TScope extends Scope = Scope> = Pick<Page.Data, 'id' | 'type'> & {
+        scope: TScope;
+    };
+    namespace Value {
+        function empty(): Value;
+        function filter(value: any): value is Value;
+        function toLinked(value: Value, page: Page.LinkedData): LinkedValue;
+        function fromData(data: Field.Data<PageField> | undefined): Value<Scope> | undefined;
+        function toData<TScope extends Scope = Scope>(value: Value<TScope>): Field.Data<PageField<TScope>>;
+    }
+    type LinkedValue<TScope extends Scope = Scope> = TScope extends 'full' ? LinkedValue.Full : TScope extends 'preview' ? LinkedValue.Preview : LinkedValue.Link;
+    namespace LinkedValue {
+        type Full = Page.LinkedData & {
+            scope: Extract<Scope, 'full'>;
+        };
+        type Preview = Page.LinkedData.AsPreview & {
+            scope: Extract<Scope, 'preview'>;
+        };
+        type Link = Page.LinkedData.AsLink & {
+            scope: Extract<Scope, 'link'>;
+        };
+        function toData({ scope, id, type }: LinkedValue): Field.Data<PageField>;
+    }
+    type Scope = 'full' | 'preview' | 'link';
+    type ConstructorArgs<TScope extends Scope = Scope> = Field.ConstructorArgs & {
+        scope: TScope;
+        pageTypes?: ReadonlyArray<string> | 'all';
+        tags?: ReadonlyArray<Tag>;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'scope' | 'required'>;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageField = void 0;
+const Page_1 = require("../../Page");
+const index_1 = require("../index");
+// class
+class PageField extends index_1.Field {
+    constructor(args) {
+        var _a, _b;
+        // construct base
+        super(args);
+        this.type = 'page';
+        // initialize instance variables
+        this.scope = args.scope;
+        this.pageTypes = (_a = args.pageTypes) !== null && _a !== void 0 ? _a : 'all';
+        this.tags = (_b = args.tags) !== null && _b !== void 0 ? _b : [];
+    }
+    modify(args) {
+        return new PageField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, scope: this.scope, pageTypes: this.pageTypes, tags: this.tags }, args));
+    }
+}
+exports.PageField = PageField;
+// extension
+(function (PageField) {
+    let Value;
+    (function (Value) {
+        // factory
+        function empty() {
+            return undefined;
+        }
+        Value.empty = empty;
+        // filter
+        function filter(value) {
+            return !!value
+                && typeof value === 'object'
+                && !Array.isArray(value)
+                && 'type' in value && typeof value.type === 'string'
+                && 'id' in value && typeof value.id === 'string';
+        }
+        Value.filter = filter;
+        function toLinked(value, page) {
+            const { scope } = value;
+            // full
+            if (scope === 'full') {
+                return Object.assign(Object.assign({}, value), page);
+            }
+            // preview
+            else if (scope === 'preview') {
+                return Object.assign(Object.assign(Object.assign({}, value), Page_1.Page.LinkedData.AsPreview.from(page)), { scope });
+            }
+            // link
+            else {
+                return Object.assign(Object.assign(Object.assign({}, value), Page_1.Page.LinkedData.AsLink.from(page)), { scope });
+            }
+        }
+        Value.toLinked = toLinked;
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                __ref: 'page',
+                type: 'page',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = PageField.Value || (PageField.Value = {}));
+    let LinkedValue;
+    (function (LinkedValue) {
+        // serialization
+        function toData({ scope, id, type }) {
+            return {
+                __ref: 'page',
+                type: 'page',
+                value: { id, type, scope }
+            };
+        }
+        LinkedValue.toData = toData;
+    })(LinkedValue = PageField.LinkedValue || (PageField.LinkedValue = {}));
+})(PageField || (exports.PageField = PageField = {}));

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

@@ -0,0 +1,71 @@
+import type { SerializedEditor } from 'lexical';
+import { Tagged } from 'type-fest';
+import { Field } from '../index';
+export declare class RichTextField extends Field<RichTextField> {
+    readonly type: "richtext";
+    readonly capabilities: Readonly<RichTextField.Capabilities.Options>;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly size: RichTextField.Size;
+    constructor(args: RichTextField.ConstructorArgs);
+    modify({ capabilities, ...args }: RichTextField.ModifyArgs): RichTextField;
+}
+export declare namespace RichTextField {
+    type Hash = Tagged<string, 'funnel.RichTextField.Hash'>;
+    type Value = SerializedEditor & {
+        hash: Hash;
+    };
+    namespace Value {
+        function fromData(data: Field.Data<RichTextField> | undefined): Value | undefined;
+        function toData(value: Value): Field.Data<RichTextField>;
+        function isEmpty(value: Value | undefined): boolean;
+    }
+    type Capabilities = Capabilities.Preset | Partial<Capabilities.Options>;
+    namespace Capabilities {
+        type Preset = 'l1' | 'l2' | 'l3';
+        type Headings = Partial<Record<Heading, string>>;
+        namespace Headings {
+            const defaults: Readonly<Headings>;
+            function isEmpty(headings: Headings | false | undefined): boolean;
+            type Item = {
+                id: Heading;
+                label: string;
+            };
+            function toArray(headings: Headings | false | undefined): Item[];
+        }
+        type Heading = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+        namespace Heading {
+            const values: ReadonlyArray<Heading>;
+        }
+        type Options = {
+            bold: boolean;
+            italics: boolean;
+            underline: boolean;
+            strikethrough: boolean;
+            superscript: boolean;
+            subscript: boolean;
+            links: boolean;
+            headings: Headings | false;
+            lists: boolean;
+            quotes: boolean;
+            hr: boolean;
+            priority: boolean;
+            accent: boolean;
+            subtle: boolean;
+        };
+        namespace Options {
+            const minimal: Options;
+            const article: Options;
+            const full: Options;
+        }
+        function parse(options: Preset | Partial<Options>): Options;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        capabilities: Capabilities;
+        minLength?: number;
+        maxLength?: number;
+        size?: Size;
+    };
+    type Size = 'sm' | 'md' | 'lg';
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}

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

@@ -0,0 +1,196 @@
+"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.RichTextField = void 0;
+const index_1 = require("../index");
+// class
+class RichTextField extends index_1.Field {
+    constructor(args) {
+        // construct base
+        super(args);
+        this.type = 'richtext';
+        // initialize instance variables
+        this.capabilities = RichTextField.Capabilities.parse(args.capabilities);
+        this.minLength = args.minLength;
+        this.maxLength = args.maxLength;
+        const intrinsicSize = getSize(args.capabilities);
+        this.size = !args.size || intrinsicSize === 'lg'
+            ? intrinsicSize
+            : args.size;
+    }
+    modify(_a) {
+        var { capabilities = {} } = _a, args = __rest(_a, ["capabilities"]);
+        return new RichTextField(Object.assign(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, minLength: this.minLength, maxLength: this.maxLength, size: this.size }, args), { capabilities: typeof capabilities === 'string'
+                ? RichTextField.Capabilities.parse(capabilities)
+                : Object.assign(Object.assign({}, this.capabilities), capabilities) }));
+    }
+}
+exports.RichTextField = RichTextField;
+// extension
+(function (RichTextField) {
+    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: 'richtext',
+                value
+            };
+        }
+        Value.toData = toData;
+        function isEmpty(value) {
+            var _a, _b;
+            const rootChildren = (_b = (_a = value === null || value === void 0 ? void 0 : value.editorState) === null || _a === void 0 ? void 0 : _a.root) === null || _b === void 0 ? void 0 : _b.children;
+            // empty if root node only has a single empty paragraph element
+            return rootChildren !== undefined
+                && rootChildren.length === 1
+                && rootChildren[0].type === 'paragraph'
+                && 'children' in rootChildren[0]
+                && Array.isArray(rootChildren[0].children)
+                && rootChildren[0].children.length === 0;
+        }
+        Value.isEmpty = isEmpty;
+    })(Value = RichTextField.Value || (RichTextField.Value = {}));
+    let Capabilities;
+    (function (Capabilities) {
+        let Headings;
+        (function (Headings) {
+            // defaults
+            Headings.defaults = {
+                h1: 'Title',
+                h2: 'Subtitle',
+                h3: 'Heading 1',
+                h4: 'Heading 2',
+                h5: 'Heading 3',
+                h6: 'Heading 4'
+            };
+            // helper
+            function isEmpty(headings) {
+                return !headings || Object.keys(headings).length === 0;
+            }
+            Headings.isEmpty = isEmpty;
+            function toArray(headings) {
+                // skip if there are no headings
+                if (!headings) {
+                    return [];
+                }
+                // or process headings
+                return Object.entries(headings)
+                    .map(([heading, label]) => ({
+                    id: heading,
+                    label
+                }))
+                    .sort((lhs, rhs) => Heading.values.indexOf(lhs.id) < Heading.values.indexOf(rhs.id) ? -1 : 1);
+            }
+            Headings.toArray = toArray;
+        })(Headings = Capabilities.Headings || (Capabilities.Headings = {}));
+        let Heading;
+        (function (Heading) {
+            // values
+            Heading.values = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+        })(Heading = Capabilities.Heading || (Capabilities.Heading = {}));
+        let Options;
+        (function (Options) {
+            Options.minimal = {
+                bold: false,
+                italics: false,
+                underline: false,
+                strikethrough: false,
+                superscript: false,
+                subscript: false,
+                links: false,
+                headings: false,
+                lists: false,
+                quotes: false,
+                hr: false,
+                priority: false,
+                accent: false,
+                subtle: false
+            };
+            Options.article = {
+                bold: true,
+                italics: true,
+                underline: true,
+                strikethrough: true,
+                superscript: true,
+                subscript: true,
+                links: true,
+                lists: true,
+                quotes: false,
+                hr: false,
+                priority: false,
+                accent: false,
+                subtle: false,
+                headings: {
+                    h2: 'Title'
+                }
+            };
+            Options.full = {
+                bold: true,
+                italics: true,
+                underline: true,
+                strikethrough: true,
+                superscript: true,
+                subscript: true,
+                links: true,
+                lists: true,
+                quotes: true,
+                hr: true,
+                priority: true,
+                accent: true,
+                subtle: true,
+                headings: Headings.defaults
+            };
+        })(Options = Capabilities.Options || (Capabilities.Options = {}));
+        // helpers
+        function parse(options) {
+            switch (options) {
+                case 'l1':
+                    return Object.assign(Object.assign({}, Options.minimal), { bold: true, italics: true, underline: true, superscript: true, subscript: true });
+                case 'l2':
+                    return Object.assign(Object.assign({}, Options.minimal), { bold: true, italics: true, underline: true, superscript: true, subscript: true, links: true });
+                case 'l3':
+                    return Object.assign(Object.assign({}, Options.minimal), { bold: true, italics: true, underline: true, strikethrough: true, superscript: true, subscript: true, links: true, headings: Headings.defaults, lists: true, quotes: true, hr: true });
+                default:
+                    return Object.assign(Object.assign({}, Options.minimal), options);
+            }
+        }
+        Capabilities.parse = parse;
+    })(Capabilities = RichTextField.Capabilities || (RichTextField.Capabilities = {}));
+})(RichTextField || (exports.RichTextField = RichTextField = {}));
+// helpers
+function getSize(capabilities) {
+    // go with default scaling (if applicable)
+    if (capabilities === 'l1') {
+        return 'sm';
+    }
+    else if (capabilities === 'l2') {
+        return 'md';
+    }
+    else if (capabilities === 'l3') {
+        return 'lg';
+    }
+    // or large if there are lists/breaks
+    const { headings, lists, quotes, hr } = capabilities;
+    if (headings || lists || quotes || hr) {
+        return 'lg';
+    }
+    // otherwise, small
+    else {
+        return 'sm';
+    }
+}

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

@@ -0,0 +1,33 @@
+import { Field } from '../index';
+export declare class TextField extends Field<TextField> {
+    readonly type: "text";
+    readonly semantics: TextField.Semantics;
+    readonly regex?: RegExp;
+    readonly exact?: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    constructor(args: TextField.ConstructorArgs);
+    modify(args: TextField.ModifyArgs): TextField;
+}
+export declare namespace TextField {
+    type Value = string;
+    namespace Value {
+        function fromData(data: Field.Data<TextField> | undefined): string | undefined;
+        function toData(value: Value): Field.Data<TextField>;
+        function coerceData(value: Value | undefined): Field.Data<TextField> | undefined;
+    }
+    namespace Regex {
+        function email(): RegExp;
+        function slug(): RegExp;
+        function password(): RegExp;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        semantics?: Semantics;
+        regex?: RegExp;
+        exact?: string;
+        minLength?: number;
+        maxLength?: number;
+    };
+    type Semantics = 'short' | 'long' | 'slug' | 'uri' | 'url' | 'email' | 'phone' | 'phone-intl' | 'password' | 'password-input' | 'integer';
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}