@nascentdigital/funnel-core 4.4.4

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

@@ -0,0 +1,148 @@
+import { AspectRatio, Size } from '../../../ui/geometry';
+import { MimeType } from '../../../ui/MimeType';
+import { Position } from '../../../ui/Position';
+import { Asset } from '../../Asset';
+import { AssetScope } from '../../AssetScope';
+import { Tag } from '../../Tag';
+import { TagGroup } from '../../TagGroup';
+import { Field } from '../index';
+export declare class AssetField<TValue extends AssetField.LinkedValue = AssetField.LinkedValue> extends Field<AssetField<TValue>> {
+    readonly type: "asset";
+    readonly mimeTypes: ReadonlyArray<TValue['type']>;
+    readonly minSize?: number;
+    readonly maxSize?: number;
+    readonly visualOptions?: AssetField.ConstructorArgs.VisualOptions;
+    readonly scope: AssetScope.Range;
+    readonly tags: ReadonlyArray<Tag>;
+    constructor({ mimeTypes, minSize, maxSize, visualOptions, scope, tags, ...args }: AssetField.ConstructorArgs<TValue>);
+    modify({ tags, ...args }: AssetField.ModifyArgs<TValue>): AssetField<TValue>;
+}
+export declare namespace AssetField {
+    type Tags = Tags.Image | Tags.Video;
+    namespace Tags {
+        const image: TagGroup<"nd.image", "ad" | "icon" | "brand" | "hero" | "background" | "person" | "logo" | "product" | "lifestyle">;
+        type Image = TagGroup.Keys<typeof image>;
+        namespace Image {
+            function parse(tags?: Image | ReadonlyArray<Image>): Tag<"nd.image", "ad" | "icon" | "brand" | "hero" | "background" | "person" | "logo" | "product" | "lifestyle">[] | undefined;
+        }
+        const video: TagGroup<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">;
+        type Video = TagGroup.Keys<typeof video>;
+        namespace Video {
+            function parse(tags?: Video | ReadonlyArray<Video>): Tag<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">[] | undefined;
+        }
+        function parse(tags?: Tags | ReadonlyArray<Tags>): (Tag<"nd.image", "ad" | "icon" | "brand" | "hero" | "background" | "person" | "logo" | "product" | "lifestyle"> | Tag<"nd.video", "ad" | "brand" | "background" | "product" | "education" | "promo">)[] | undefined;
+    }
+    type Value<T extends LinkedValue = LinkedValue> = Pick<T, 'id' | 'type' | 'url'>;
+    namespace Value {
+        function filter(value: any): value is Value;
+        function fromData(data: Field.Data<AssetField> | undefined): Value<LinkedValue> | undefined;
+        function toData(value: Value): Field.Data<AssetField>;
+        function toLinked(value: Value, data: Asset.Linked): LinkedValue;
+    }
+    type LinkedValue = LinkedValue.Image | LinkedValue.Video | LinkedValue.Audio | LinkedValue.Document;
+    namespace LinkedValue {
+        type Base = {
+            id: Asset.Id;
+            brand?: string;
+            url: string;
+            size: number;
+            name: string;
+            description?: string | null;
+            scope: AssetScope.Data;
+            tags: TagGroup.Data;
+        };
+        type Visual = Image | Video;
+        namespace Visual {
+            function filter(value: any): value is Visual;
+        }
+        type Image = Base & {
+            type: MimeType.Image;
+            metadata: Image.Metadata;
+        };
+        namespace Image {
+            type Metadata = {
+                crop: Position;
+                dimensions: Size;
+                blurHash?: string;
+                thumbUrl?: string;
+            };
+            function filter(value: any): value is Image;
+        }
+        type Video = Base & {
+            type: MimeType.Video;
+            metadata: Video.Metadata;
+        };
+        namespace Video {
+            type Metadata = {
+                crop: Position;
+                dimensions: Size;
+                blurHash?: string;
+                accessible: boolean | 'system';
+            };
+            function filter(value: any): value is Video;
+        }
+        type Audio = Base & {
+            type: MimeType.Audio;
+            metadata: Audio.Metadata;
+        };
+        namespace Audio {
+            type Metadata = {
+                crop: Position;
+                size: Size;
+                accessible: boolean | 'system';
+            };
+            function filter(value: any): value is Audio;
+        }
+        type Document = Base & {
+            type: MimeType.Document;
+            metadata: Document.Metadata;
+        };
+        namespace Document {
+            type Metadata = {};
+            function filter(value: any): value is Document;
+        }
+        function filter(value: any): value is LinkedValue;
+        function unlink(value: LinkedValue): Value;
+        function toData(value: LinkedValue): Field.LinkedData<AssetField>;
+    }
+    type VisualData = Field.LinkedData<AssetField<LinkedValue.Image | LinkedValue.Video>>;
+    type ImageData = Field.LinkedData<AssetField<LinkedValue.Image>>;
+    type VideoData = Field.LinkedData<AssetField<LinkedValue.Video>>;
+    type AudioData = Field.LinkedData<AssetField<LinkedValue.Audio>>;
+    type DocumentData = Field.LinkedData<AssetField<LinkedValue.Document>>;
+    type ConstructorArgs<TValue extends AssetField.LinkedValue = AssetField.LinkedValue> = Field.ConstructorArgs & {
+        mimeTypes: ReadonlyArray<TValue['type']>;
+        minSize?: number;
+        maxSize?: number;
+        visualOptions?: ConstructorArgs.VisualOptions;
+        scope?: AssetScope.Range;
+        tags?: ReadonlyArray<Tag>;
+    };
+    namespace ConstructorArgs {
+        type VisualOptions = {
+            minWidth?: number;
+            maxWidth?: number;
+            minHeight?: number;
+            maxHeight?: number;
+            aspectRatio?: AspectRatio;
+        };
+        type ForVisual = Omit<ConstructorArgs, 'mimeTypes' | 'tags'> & {
+            mimeTypes?: ReadonlyArray<MimeType.Image | MimeType.Video>;
+            visualOptions?: VisualOptions;
+            tags?: Tags | ReadonlyArray<Tags>;
+        };
+        type ForImage = Omit<ConstructorArgs, 'mimeTypes' | 'tags'> & {
+            mimeTypes?: ReadonlyArray<MimeType.Image>;
+            visualOptions?: VisualOptions;
+            tags?: Tags.Image | ReadonlyArray<Tags.Image>;
+        };
+        type ForVideo = Omit<ConstructorArgs, 'mimeTypes' | 'tags'> & {
+            mimeTypes?: ReadonlyArray<MimeType.Video>;
+            visualOptions?: VisualOptions;
+            tags?: Tags.Video | ReadonlyArray<Tags.Video>;
+        };
+    }
+    type ModifyArgs<TValue extends AssetField.LinkedValue> = Omit<Partial<ConstructorArgs<TValue>>, 'tags' | 'required'> & {
+        tags?: Tags | ReadonlyArray<Tags>;
+    };
+}

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

@@ -0,0 +1,206 @@
+"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.AssetField = void 0;
+const errors_1 = require("../../../errors");
+const MimeType_1 = require("../../../ui/MimeType");
+const utils_1 = require("../../../utils");
+const TagGroup_1 = require("../../TagGroup");
+const index_1 = require("../index");
+// class
+class AssetField extends index_1.Field {
+    constructor(_a) {
+        var { mimeTypes, minSize, maxSize, visualOptions, scope = 'instance', tags = [] } = _a, args = __rest(_a, ["mimeTypes", "minSize", "maxSize", "visualOptions", "scope", "tags"]);
+        // construct base
+        super(args);
+        this.type = 'asset';
+        // throw if there isn't at least one mime type
+        const [mimeType] = mimeTypes;
+        if (!mimeType) {
+            throw new errors_1.ArgumentError('At least one MimeType must be provided');
+        }
+        // initialize instance variables
+        this.mimeTypes = mimeTypes.slice();
+        this.minSize = minSize;
+        this.maxSize = maxSize;
+        this.visualOptions = visualOptions;
+        this.scope = scope;
+        this.tags = tags;
+    }
+    modify(_a) {
+        var { tags } = _a, args = __rest(_a, ["tags"]);
+        return new AssetField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, mimeTypes: this.mimeTypes, minSize: this.minSize, maxSize: this.maxSize, visualOptions: this.visualOptions, scope: this.scope, tags: tags ? AssetField.Tags.parse(tags) : this.tags }, args));
+    }
+}
+exports.AssetField = AssetField;
+// extension
+(function (AssetField) {
+    let Tags;
+    (function (Tags) {
+        // image
+        Tags.image = TagGroup_1.TagGroup.create({
+            id: 'nd.image',
+            name: 'Image Type',
+            tags: {
+                brand: 'Brand',
+                hero: 'Hero',
+                background: 'Background',
+                person: 'Person',
+                icon: 'Icon',
+                logo: 'Logo',
+                product: 'Product',
+                lifestyle: 'Lifestyle',
+                ad: 'Advertisement'
+            }
+        });
+        let Image;
+        (function (Image) {
+            // helpers
+            function parse(tags) {
+                return tags
+                    ? Tags.image.extract(...(Array.isArray(tags) ? tags : [tags]))
+                    : undefined;
+            }
+            Image.parse = parse;
+        })(Image = Tags.Image || (Tags.Image = {}));
+        // video
+        Tags.video = TagGroup_1.TagGroup.create({
+            id: 'nd.video',
+            name: 'Video Type',
+            tags: {
+                brand: 'Brand',
+                background: 'Background',
+                product: 'Product',
+                education: 'Educational',
+                promo: 'Promotional',
+                ad: 'Advertisement'
+            }
+        });
+        let Video;
+        (function (Video) {
+            // helpers
+            function parse(tags) {
+                return tags
+                    ? Tags.video.extract(...(Array.isArray(tags) ? tags : [tags]))
+                    : undefined;
+            }
+            Video.parse = parse;
+        })(Video = Tags.Video || (Tags.Video = {}));
+        // helpers
+        function parse(tags) {
+            // skip if there are no tags
+            if (!tags) {
+                return undefined;
+            }
+            // extract tags
+            const tagsIds = Array.isArray(tags) ? tags : [tags];
+            return tagsIds
+                .flatMap(tagId => [Tags.image.get(tagId), Tags.video.get(tagId)])
+                .filter(utils_1.Value.isDefined);
+        }
+        Tags.parse = parse;
+    })(Tags = AssetField.Tags || (AssetField.Tags = {}));
+    let Value;
+    (function (Value) {
+        // guard
+        function filter(value) {
+            return !!value
+                && typeof value === 'object'
+                && !Array.isArray(value)
+                && 'id' in value
+                && !!value.id && typeof value.id === 'string'
+                && 'type' in value && MimeType_1.MimeType.filter(value.type);
+        }
+        Value.filter = filter;
+        // serialization
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+        function toData(value) {
+            return {
+                __ref: 'asset',
+                type: 'asset',
+                value
+            };
+        }
+        Value.toData = toData;
+        function toLinked(value, data) {
+            return Object.assign(Object.assign({}, value), data.value);
+        }
+        Value.toLinked = toLinked;
+    })(Value = AssetField.Value || (AssetField.Value = {}));
+    let LinkedValue;
+    (function (LinkedValue) {
+        let Visual;
+        (function (Visual) {
+            function filter(value) {
+                return LinkedValue.filter(value)
+                    && (MimeType_1.MimeType.image.includes(value.type)
+                        || MimeType_1.MimeType.video.includes(value.type));
+            }
+            Visual.filter = filter;
+        })(Visual = LinkedValue.Visual || (LinkedValue.Visual = {}));
+        let Image;
+        (function (Image) {
+            function filter(value) {
+                return LinkedValue.filter(value)
+                    && MimeType_1.MimeType.image.includes(value.type);
+            }
+            Image.filter = filter;
+        })(Image = LinkedValue.Image || (LinkedValue.Image = {}));
+        let Video;
+        (function (Video) {
+            function filter(value) {
+                return LinkedValue.filter(value)
+                    && MimeType_1.MimeType.video.includes(value.type);
+            }
+            Video.filter = filter;
+        })(Video = LinkedValue.Video || (LinkedValue.Video = {}));
+        let Audio;
+        (function (Audio) {
+            function filter(value) {
+                return LinkedValue.filter(value)
+                    && MimeType_1.MimeType.audio.includes(value.type);
+            }
+            Audio.filter = filter;
+        })(Audio = LinkedValue.Audio || (LinkedValue.Audio = {}));
+        let Document;
+        (function (Document) {
+            function filter(value) {
+                return LinkedValue.filter(value)
+                    && MimeType_1.MimeType.document.includes(value.type);
+            }
+            Document.filter = filter;
+        })(Document = LinkedValue.Document || (LinkedValue.Document = {}));
+        // helpers
+        function filter(value) {
+            return Value.filter(value)
+                && 'name' in value && typeof value.name === 'string';
+        }
+        LinkedValue.filter = filter;
+        function unlink(value) {
+            const { id, url, type } = value;
+            return { id, url, type };
+        }
+        LinkedValue.unlink = unlink;
+        // serialization
+        function toData(value) {
+            return {
+                type: 'asset',
+                value
+            };
+        }
+        LinkedValue.toData = toData;
+    })(LinkedValue = AssetField.LinkedValue || (AssetField.LinkedValue = {}));
+})(AssetField || (exports.AssetField = AssetField = {}));

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

@@ -0,0 +1,21 @@
+import { Field } from '../index';
+export declare class BooleanField extends Field<BooleanField> {
+    readonly type: "boolean";
+    readonly semantics: BooleanField.Semantics;
+    readonly defaultValue: boolean;
+    constructor(args: BooleanField.ConstructorArgs);
+    modify(args: BooleanField.ModifyArgs): BooleanField;
+}
+export declare namespace BooleanField {
+    type Value = boolean;
+    namespace Value {
+        function fromData(data: Field.Data<BooleanField> | undefined): boolean | undefined;
+        function toData(value: Value): Field.Data<BooleanField>;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        semantics?: Semantics;
+        defaultValue?: boolean;
+    };
+    type Semantics = 'check' | 'toggle';
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanField = void 0;
+const index_1 = require("../index");
+// class
+class BooleanField extends index_1.Field {
+    constructor(args) {
+        var _a, _b;
+        // construct base
+        super(args);
+        this.type = 'boolean';
+        // initialize instance variables
+        this.semantics = (_a = args.semantics) !== null && _a !== void 0 ? _a : 'toggle';
+        this.defaultValue = (_b = args.defaultValue) !== null && _b !== void 0 ? _b : false;
+    }
+    modify(args) {
+        return new BooleanField(Object.assign({ semantics: this.semantics, name: this.name, hint: this.hint, description: this.description, required: this.required, defaultValue: this.defaultValue }, args));
+    }
+}
+exports.BooleanField = BooleanField;
+// extension
+(function (BooleanField) {
+    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: 'boolean',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = BooleanField.Value || (BooleanField.Value = {}));
+})(BooleanField || (exports.BooleanField = BooleanField = {}));

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

@@ -0,0 +1,34 @@
+import { Collection } from '../../Collection';
+import { Tag } from '../../Tag';
+import { Field } from '../index';
+export declare class CollectionField<TCollection extends Collection = Collection> extends Field<CollectionField<TCollection>> {
+    readonly type: "collection";
+    readonly collections: ReadonlyArray<TCollection>;
+    readonly tags: ReadonlyArray<Tag>;
+    constructor(args: CollectionField.ConstructorArgs<TCollection>);
+    modify(args: CollectionField.ModifyArgs<TCollection>): CollectionField<TCollection>;
+}
+export declare namespace CollectionField {
+    type Value<TCollection extends Collection = Collection> = Value.ForRef<TCollection> | Value.ForInline<TCollection>;
+    namespace Value {
+        type ForRef<TCollection extends Collection = Collection> = Pick<Collection.Data<TCollection>, 'id' | 'type'>;
+        namespace ForRef {
+            function filter<TCollection extends Collection = Collection>(value: any): value is ForRef<TCollection>;
+            function toData(value: ForRef): Field.Data.Collection.Ref;
+        }
+        type ForInline<TCollection extends Collection = Collection> = Collection.Data.AsInline<TCollection>;
+        namespace ForInline {
+            function filter<TCollection extends Collection = Collection>(value: any): value is ForInline<TCollection>;
+            function toData(value: ForInline): Field.Data.Collection.Inline;
+        }
+        function empty(): Value;
+        function toData(value: Value): Field.Data<CollectionField>;
+        function fromData(data: Field.Data<CollectionField> | undefined): ForRef<Collection<import("../..").Fields>> | ForInline<Collection<import("../..").Fields>> | undefined;
+    }
+    type LinkedValue<TCollection extends Collection = Collection> = Collection.LinkedData<TCollection>;
+    type ConstructorArgs<TCollection extends Collection> = Field.ConstructorArgs & {
+        collections: TCollection | ReadonlyArray<TCollection>;
+        tags?: ReadonlyArray<Tag>;
+    };
+    type ModifyArgs<TCollection extends Collection> = Omit<Partial<ConstructorArgs<TCollection>>, 'required'>;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionField = void 0;
+const index_1 = require("../index");
+// class
+class CollectionField extends index_1.Field {
+    constructor(args) {
+        var _a;
+        // construct base
+        super(args);
+        this.type = 'collection';
+        // initialize instance variables
+        this.collections = Array.isArray(args.collections)
+            ? args.collections
+            : [args.collections];
+        this.tags = (_a = args.tags) !== null && _a !== void 0 ? _a : [];
+    }
+    modify(args) {
+        return new CollectionField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, collections: this.collections, tags: this.tags }, args));
+    }
+}
+exports.CollectionField = CollectionField;
+// extension
+(function (CollectionField) {
+    let Value;
+    (function (Value) {
+        let ForRef;
+        (function (ForRef) {
+            // guard
+            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';
+            }
+            ForRef.filter = filter;
+            // serialization
+            function toData(value) {
+                return {
+                    __ref: 'collection',
+                    type: 'collection',
+                    value
+                };
+            }
+            ForRef.toData = toData;
+        })(ForRef = Value.ForRef || (Value.ForRef = {}));
+        let ForInline;
+        (function (ForInline) {
+            // guard
+            function filter(value) {
+                return !!value
+                    && typeof value === 'object'
+                    && !Array.isArray(value)
+                    && 'type' in value && typeof value.type === 'string'
+                    && !('id' in value);
+            }
+            ForInline.filter = filter;
+            // serialization
+            function toData(value) {
+                return {
+                    type: 'collection',
+                    value
+                };
+            }
+            ForInline.toData = toData;
+        })(ForInline = Value.ForInline || (Value.ForInline = {}));
+        // factory
+        function empty() {
+            return undefined;
+        }
+        Value.empty = empty;
+        // serialization
+        function toData(value) {
+            return ForRef.filter(value)
+                ? ForRef.toData(value)
+                : ForInline.toData(value);
+        }
+        Value.toData = toData;
+        function fromData(data) {
+            return data === null || data === void 0 ? void 0 : data.value;
+        }
+        Value.fromData = fromData;
+    })(Value = CollectionField.Value || (CollectionField.Value = {}));
+})(CollectionField || (exports.CollectionField = CollectionField = {}));

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

@@ -0,0 +1,21 @@
+import { DateString } from '../../../types';
+import { Field } from '../index';
+export declare class DateField extends Field<DateField> {
+    readonly type: "date";
+    readonly minDate?: DateString;
+    readonly maxDate?: DateString;
+    constructor(args: DateField.ConstructorArgs);
+    modify(args: DateField.ModifyArgs): DateField;
+}
+export declare namespace DateField {
+    type Value = DateString;
+    namespace Value {
+        function fromData(data: Field.Data<DateField> | undefined): `${number}-01-01` | `${number}-01-02` | `${number}-01-03` | `${number}-01-04` | `${number}-01-05` | `${number}-01-06` | `${number}-01-07` | `${number}-01-08` | `${number}-01-09` | `${number}-01-10` | `${number}-01-11` | `${number}-01-12` | `${number}-01-13` | `${number}-01-14` | `${number}-01-15` | `${number}-01-16` | `${number}-01-17` | `${number}-01-18` | `${number}-01-19` | `${number}-01-20` | `${number}-01-21` | `${number}-01-22` | `${number}-01-23` | `${number}-01-24` | `${number}-01-25` | `${number}-01-26` | `${number}-01-27` | `${number}-01-28` | `${number}-01-29` | `${number}-01-30` | `${number}-01-31` | `${number}-02-01` | `${number}-02-02` | `${number}-02-03` | `${number}-02-04` | `${number}-02-05` | `${number}-02-06` | `${number}-02-07` | `${number}-02-08` | `${number}-02-09` | `${number}-02-10` | `${number}-02-11` | `${number}-02-12` | `${number}-02-13` | `${number}-02-14` | `${number}-02-15` | `${number}-02-16` | `${number}-02-17` | `${number}-02-18` | `${number}-02-19` | `${number}-02-20` | `${number}-02-21` | `${number}-02-22` | `${number}-02-23` | `${number}-02-24` | `${number}-02-25` | `${number}-02-26` | `${number}-02-27` | `${number}-02-28` | `${number}-02-29` | `${number}-02-30` | `${number}-02-31` | `${number}-03-01` | `${number}-03-02` | `${number}-03-03` | `${number}-03-04` | `${number}-03-05` | `${number}-03-06` | `${number}-03-07` | `${number}-03-08` | `${number}-03-09` | `${number}-03-10` | `${number}-03-11` | `${number}-03-12` | `${number}-03-13` | `${number}-03-14` | `${number}-03-15` | `${number}-03-16` | `${number}-03-17` | `${number}-03-18` | `${number}-03-19` | `${number}-03-20` | `${number}-03-21` | `${number}-03-22` | `${number}-03-23` | `${number}-03-24` | `${number}-03-25` | `${number}-03-26` | `${number}-03-27` | `${number}-03-28` | `${number}-03-29` | `${number}-03-30` | `${number}-03-31` | `${number}-04-01` | `${number}-04-02` | `${number}-04-03` | `${number}-04-04` | `${number}-04-05` | `${number}-04-06` | `${number}-04-07` | `${number}-04-08` | `${number}-04-09` | `${number}-04-10` | `${number}-04-11` | `${number}-04-12` | `${number}-04-13` | `${number}-04-14` | `${number}-04-15` | `${number}-04-16` | `${number}-04-17` | `${number}-04-18` | `${number}-04-19` | `${number}-04-20` | `${number}-04-21` | `${number}-04-22` | `${number}-04-23` | `${number}-04-24` | `${number}-04-25` | `${number}-04-26` | `${number}-04-27` | `${number}-04-28` | `${number}-04-29` | `${number}-04-30` | `${number}-04-31` | `${number}-05-01` | `${number}-05-02` | `${number}-05-03` | `${number}-05-04` | `${number}-05-05` | `${number}-05-06` | `${number}-05-07` | `${number}-05-08` | `${number}-05-09` | `${number}-05-10` | `${number}-05-11` | `${number}-05-12` | `${number}-05-13` | `${number}-05-14` | `${number}-05-15` | `${number}-05-16` | `${number}-05-17` | `${number}-05-18` | `${number}-05-19` | `${number}-05-20` | `${number}-05-21` | `${number}-05-22` | `${number}-05-23` | `${number}-05-24` | `${number}-05-25` | `${number}-05-26` | `${number}-05-27` | `${number}-05-28` | `${number}-05-29` | `${number}-05-30` | `${number}-05-31` | `${number}-06-01` | `${number}-06-02` | `${number}-06-03` | `${number}-06-04` | `${number}-06-05` | `${number}-06-06` | `${number}-06-07` | `${number}-06-08` | `${number}-06-09` | `${number}-06-10` | `${number}-06-11` | `${number}-06-12` | `${number}-06-13` | `${number}-06-14` | `${number}-06-15` | `${number}-06-16` | `${number}-06-17` | `${number}-06-18` | `${number}-06-19` | `${number}-06-20` | `${number}-06-21` | `${number}-06-22` | `${number}-06-23` | `${number}-06-24` | `${number}-06-25` | `${number}-06-26` | `${number}-06-27` | `${number}-06-28` | `${number}-06-29` | `${number}-06-30` | `${number}-06-31` | `${number}-07-01` | `${number}-07-02` | `${number}-07-03` | `${number}-07-04` | `${number}-07-05` | `${number}-07-06` | `${number}-07-07` | `${number}-07-08` | `${number}-07-09` | `${number}-07-10` | `${number}-07-11` | `${number}-07-12` | `${number}-07-13` | `${number}-07-14` | `${number}-07-15` | `${number}-07-16` | `${number}-07-17` | `${number}-07-18` | `${number}-07-19` | `${number}-07-20` | `${number}-07-21` | `${number}-07-22` | `${number}-07-23` | `${number}-07-24` | `${number}-07-25` | `${number}-07-26` | `${number}-07-27` | `${number}-07-28` | `${number}-07-29` | `${number}-07-30` | `${number}-07-31` | `${number}-08-01` | `${number}-08-02` | `${number}-08-03` | `${number}-08-04` | `${number}-08-05` | `${number}-08-06` | `${number}-08-07` | `${number}-08-08` | `${number}-08-09` | `${number}-08-10` | `${number}-08-11` | `${number}-08-12` | `${number}-08-13` | `${number}-08-14` | `${number}-08-15` | `${number}-08-16` | `${number}-08-17` | `${number}-08-18` | `${number}-08-19` | `${number}-08-20` | `${number}-08-21` | `${number}-08-22` | `${number}-08-23` | `${number}-08-24` | `${number}-08-25` | `${number}-08-26` | `${number}-08-27` | `${number}-08-28` | `${number}-08-29` | `${number}-08-30` | `${number}-08-31` | `${number}-09-01` | `${number}-09-02` | `${number}-09-03` | `${number}-09-04` | `${number}-09-05` | `${number}-09-06` | `${number}-09-07` | `${number}-09-08` | `${number}-09-09` | `${number}-09-10` | `${number}-09-11` | `${number}-09-12` | `${number}-09-13` | `${number}-09-14` | `${number}-09-15` | `${number}-09-16` | `${number}-09-17` | `${number}-09-18` | `${number}-09-19` | `${number}-09-20` | `${number}-09-21` | `${number}-09-22` | `${number}-09-23` | `${number}-09-24` | `${number}-09-25` | `${number}-09-26` | `${number}-09-27` | `${number}-09-28` | `${number}-09-29` | `${number}-09-30` | `${number}-09-31` | `${number}-10-01` | `${number}-10-02` | `${number}-10-03` | `${number}-10-04` | `${number}-10-05` | `${number}-10-06` | `${number}-10-07` | `${number}-10-08` | `${number}-10-09` | `${number}-10-10` | `${number}-10-11` | `${number}-10-12` | `${number}-10-13` | `${number}-10-14` | `${number}-10-15` | `${number}-10-16` | `${number}-10-17` | `${number}-10-18` | `${number}-10-19` | `${number}-10-20` | `${number}-10-21` | `${number}-10-22` | `${number}-10-23` | `${number}-10-24` | `${number}-10-25` | `${number}-10-26` | `${number}-10-27` | `${number}-10-28` | `${number}-10-29` | `${number}-10-30` | `${number}-10-31` | `${number}-11-01` | `${number}-11-02` | `${number}-11-03` | `${number}-11-04` | `${number}-11-05` | `${number}-11-06` | `${number}-11-07` | `${number}-11-08` | `${number}-11-09` | `${number}-11-10` | `${number}-11-11` | `${number}-11-12` | `${number}-11-13` | `${number}-11-14` | `${number}-11-15` | `${number}-11-16` | `${number}-11-17` | `${number}-11-18` | `${number}-11-19` | `${number}-11-20` | `${number}-11-21` | `${number}-11-22` | `${number}-11-23` | `${number}-11-24` | `${number}-11-25` | `${number}-11-26` | `${number}-11-27` | `${number}-11-28` | `${number}-11-29` | `${number}-11-30` | `${number}-11-31` | `${number}-12-01` | `${number}-12-02` | `${number}-12-03` | `${number}-12-04` | `${number}-12-05` | `${number}-12-06` | `${number}-12-07` | `${number}-12-08` | `${number}-12-09` | `${number}-12-10` | `${number}-12-11` | `${number}-12-12` | `${number}-12-13` | `${number}-12-14` | `${number}-12-15` | `${number}-12-16` | `${number}-12-17` | `${number}-12-18` | `${number}-12-19` | `${number}-12-20` | `${number}-12-21` | `${number}-12-22` | `${number}-12-23` | `${number}-12-24` | `${number}-12-25` | `${number}-12-26` | `${number}-12-27` | `${number}-12-28` | `${number}-12-29` | `${number}-12-30` | `${number}-12-31` | undefined;
+        function toData(value: Value): Field.Data<DateField>;
+    }
+    type ConstructorArgs = Field.ConstructorArgs & {
+        minDate?: DateString;
+        maxDate?: DateString;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateField = void 0;
+const index_1 = require("../index");
+// class
+class DateField extends index_1.Field {
+    constructor(args) {
+        // construct base
+        super(args);
+        this.type = 'date';
+        // initialize instance variables
+        this.minDate = args.minDate;
+        this.maxDate = args.maxDate;
+    }
+    modify(args) {
+        return new DateField(Object.assign({ name: this.name, hint: this.hint, description: this.description, required: this.required, minDate: this.minDate, maxDate: this.maxDate }, args));
+    }
+}
+exports.DateField = DateField;
+// extension
+(function (DateField) {
+    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: 'date',
+                value
+            };
+        }
+        Value.toData = toData;
+    })(Value = DateField.Value || (DateField.Value = {}));
+})(DateField || (exports.DateField = DateField = {}));

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

@@ -0,0 +1,36 @@
+import type { Page } from '../../Page';
+import type { PageQuery } from '../../PageQuery';
+import { Field } from '../index';
+export declare class DynamicPagesField extends Field<DynamicPagesField> {
+    readonly type: "dynamic.pages";
+    readonly types: Page.Type[] | 'all';
+    readonly size: number;
+    constructor(args: DynamicPagesField.ConstructorArgs);
+    get schema(): DynamicPagesField.Schema;
+    modify(args: DynamicPagesField.ModifyArgs): DynamicPagesField;
+}
+export declare namespace DynamicPagesField {
+    type Query = Pick<PageQuery.Data, 'types' | 'sort' | 'excludeIds' | 'limit'>;
+    type SavedQuery = Pick<Query, 'types' | 'sort'>;
+    type Value = SavedQuery & {
+        staticPages?: any[];
+    };
+    namespace Value {
+        function fromData(data: Field.Data<DynamicPagesField> | undefined): Value | undefined;
+        function toData(value: Value): Field.Data<DynamicPagesField>;
+        function coerceData(value: Value | undefined): Field.Data<DynamicPagesField> | undefined;
+    }
+    type LinkedValue = {
+        __schema: Schema;
+        pages: Array<Page.LinkedData.AsPreview>;
+    };
+    type Schema = {
+        types: Page.Type[] | 'all';
+        size: number;
+    };
+    type ConstructorArgs = Field.ConstructorArgs & {
+        types?: Page.Type[] | 'all';
+        size: number;
+    };
+    type ModifyArgs = Omit<Partial<ConstructorArgs>, 'required'>;
+}