@prismicio/types-internal 3.16.0 → 3.16.1-alpha.0

package/lib/src/customtypes/widgets/Widget.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Widgets = exports.FieldType = exports.DynamicWidget = exports.StaticWidget = exports.widgetReader = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Group_1 = require("./Group");
+const nestable_1 = require("./nestable");
+const NestableWidget_1 = require("./nestable/NestableWidget");
+const Slices_1 = require("./slices/Slices");
+const UID_1 = require("./UID");
+function widgetReader(codec) {
+    return t.union([UID_1.UID, NestableWidget_1.NestableWidget, Group_1.Group, codec]);
+}
+exports.widgetReader = widgetReader;
+exports.StaticWidget = widgetReader(Slices_1.StaticSlices);
+exports.DynamicWidget = widgetReader(Slices_1.DynamicSlices);
+exports.FieldType = t.keyof({
+    [nestable_1.ColorFieldType]: null,
+    [nestable_1.BooleanFieldType]: null,
+    [nestable_1.NumberFieldType]: null,
+    [nestable_1.EmbedFieldType]: null,
+    [nestable_1.GeoPointFieldType]: null,
+    [nestable_1.DateFieldType]: null,
+    [nestable_1.RangeFieldType]: null,
+    [nestable_1.RichTextFieldType]: null,
+    [nestable_1.SelectFieldType]: null,
+    [nestable_1.SeparatorFieldType]: null,
+    [nestable_1.TableFieldType]: null,
+    [nestable_1.TextFieldType]: null,
+    [nestable_1.TimestampFieldType]: null,
+    [nestable_1.LinkFieldType]: null,
+    [nestable_1.ImageFieldType]: null,
+    [nestable_1.IntegrationFieldType]: null,
+    [UID_1.UIDFieldType]: null,
+    [Group_1.GroupFieldType]: null,
+    [Slices_1.SlicesFieldType]: null,
+    [Slices_1.LegacySlicesFieldType]: null,
+});
+exports.Widgets = {
+    toStatic(widget, sharedSlices) {
+        switch (widget.type) {
+            case "Choice":
+            case "Slices":
+                return Slices_1.Slices.toStatic(widget, sharedSlices);
+            default:
+                return widget;
+        }
+    },
+};

package/lib/src/customtypes/widgets/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Group";
+export * from "./nestable";
+export * from "./shared";
+export * from "./slices";
+export * from "./UID";
+export * from "./Widget";

package/lib/src/customtypes/widgets/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Group"), exports);
+(0, tslib_1.__exportStar)(require("./nestable"), exports);
+(0, tslib_1.__exportStar)(require("./shared"), exports);
+(0, tslib_1.__exportStar)(require("./slices"), exports);
+(0, tslib_1.__exportStar)(require("./UID"), exports);
+(0, tslib_1.__exportStar)(require("./Widget"), exports);

package/lib/src/customtypes/widgets/nestable/BooleanField.d.ts

@@ -0,0 +1,20 @@
+import * as t from "io-ts";
+export declare const BooleanFieldType = "Boolean";
+export declare const BooleanConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    default_value: t.BooleanC;
+    placeholder_true: t.StringC;
+    placeholder_false: t.StringC;
+}>>;
+export declare type BooleanConfig = t.TypeOf<typeof BooleanConfig>;
+export declare const BooleanField: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Boolean">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        default_value: t.BooleanC;
+        placeholder_true: t.StringC;
+        placeholder_false: t.StringC;
+    }>>;
+}>]>>;
+export declare type BooleanField = t.TypeOf<typeof BooleanField>;

package/lib/src/customtypes/widgets/nestable/BooleanField.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanField = exports.BooleanConfig = exports.BooleanFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.BooleanFieldType = "Boolean";
+exports.BooleanConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    default_value: t.boolean,
+    placeholder_true: t.string,
+    placeholder_false: t.string,
+}));
+exports.BooleanField = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.BooleanFieldType),
+    }),
+    t.partial({
+        config: exports.BooleanConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/Color.d.ts

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+export declare const ColorFieldType = "Color";
+export declare const ColorConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+}>>;
+export declare type ColorConfig = t.TypeOf<typeof ColorConfig>;
+export declare const Color: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Color">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+    }>>;
+}>]>>;
+export declare type Color = t.TypeOf<typeof Color>;

package/lib/src/customtypes/widgets/nestable/Color.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = exports.ColorConfig = exports.ColorFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.ColorFieldType = "Color";
+exports.ColorConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+}));
+exports.Color = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.ColorFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.ColorConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/Date.d.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+export declare const DateFieldType = "Date";
+export declare const DateConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    default: t.StringC;
+}>>;
+export declare type DateConfig = t.TypeOf<typeof DateConfig>;
+export declare const Date: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Date">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        default: t.StringC;
+    }>>;
+}>]>>;
+export declare type Date = t.TypeOf<typeof Date>;

package/lib/src/customtypes/widgets/nestable/Date.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Date = exports.DateConfig = exports.DateFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.DateFieldType = "Date";
+exports.DateConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    default: t.string,
+}));
+exports.Date = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.DateFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.DateConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/Embed.d.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+export declare const EmbedFieldType = "Embed";
+export declare const EmbedConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    useAsTitle: t.BooleanC;
+}>>;
+export declare type EmbedConfig = t.TypeOf<typeof EmbedConfig>;
+export declare const Embed: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Embed">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        useAsTitle: t.BooleanC;
+    }>>;
+}>]>>;
+export declare type Embed = t.TypeOf<typeof Embed>;

package/lib/src/customtypes/widgets/nestable/Embed.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embed = exports.EmbedConfig = exports.EmbedFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.EmbedFieldType = "Embed";
+exports.EmbedConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    useAsTitle: t.boolean,
+}));
+exports.Embed = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.EmbedFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.EmbedConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/GeoPoint.d.ts

@@ -0,0 +1,15 @@
+import * as t from "io-ts";
+export declare const GeoPointFieldType = "GeoPoint";
+export declare const GeoPointConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>>;
+export declare type GeoPointConfig = t.TypeOf<typeof GeoPointConfig>;
+export declare const GeoPoint: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"GeoPoint">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>;
+export declare type GeoPoint = t.TypeOf<typeof GeoPoint>;

package/lib/src/customtypes/widgets/nestable/GeoPoint.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPoint = exports.GeoPointConfig = exports.GeoPointFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.GeoPointFieldType = "GeoPoint";
+exports.GeoPointConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+}));
+exports.GeoPoint = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.GeoPointFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.GeoPointConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/Image.d.ts

@@ -0,0 +1,44 @@
+import * as t from "io-ts";
+export declare const ImageFieldType = "Image";
+export declare const Thumbnail: t.ExactC<t.IntersectionC<[t.TypeC<{
+    name: t.StringC;
+}>, t.PartialC<{
+    width: t.Type<number | null, unknown, unknown>;
+    height: t.Type<number | null, unknown, unknown>;
+}>]>>;
+export declare type Thumbnail = t.TypeOf<typeof Thumbnail>;
+export declare const ImageConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    constraint: t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+    }>;
+    thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+        name: t.StringC;
+    }>, t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+    }>]>>>;
+}>>;
+export declare type ImageConfig = t.TypeOf<typeof ImageConfig>;
+export declare const Image: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Image">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        constraint: t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>;
+        thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+            name: t.StringC;
+        }>, t.PartialC<{
+            width: t.Type<number | null, unknown, unknown>;
+            height: t.Type<number | null, unknown, unknown>;
+        }>]>>>;
+    }>>;
+}>]>>;
+export declare type Image = t.TypeOf<typeof Image>;

package/lib/src/customtypes/widgets/nestable/Image.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Image = exports.ImageConfig = exports.Thumbnail = exports.ImageFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const ImageConstraint_1 = (0, tslib_1.__importDefault)(require("../shared/ImageConstraint"));
+exports.ImageFieldType = "Image";
+exports.Thumbnail = t.exact(t.intersection([
+    t.type({
+        name: t.string,
+    }),
+    ImageConstraint_1.default,
+]));
+exports.ImageConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    constraint: ImageConstraint_1.default,
+    thumbnails: t.readonlyArray(exports.Thumbnail),
+}));
+exports.Image = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.ImageFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.ImageConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/IntegrationField.d.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+export declare const IntegrationFieldType = "IntegrationFields";
+export declare const IntegrationFieldConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    catalog: t.StringC;
+}>>;
+export declare type IntegrationFieldConfig = t.TypeOf<typeof IntegrationFieldConfig>;
+export declare const IntegrationField: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"IntegrationFields">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        placeholder: t.StringC;
+        catalog: t.StringC;
+    }>>;
+}>]>>;
+export declare type IntegrationField = t.TypeOf<typeof IntegrationField>;

package/lib/src/customtypes/widgets/nestable/IntegrationField.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationField = exports.IntegrationFieldConfig = exports.IntegrationFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.IntegrationFieldType = "IntegrationFields";
+exports.IntegrationFieldConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    catalog: t.string,
+}));
+exports.IntegrationField = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.IntegrationFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.IntegrationFieldConfig,
+    }),
+]));

package/lib/src/customtypes/widgets/nestable/Link.d.ts

@@ -0,0 +1,196 @@
+import * as t from "io-ts";
+export declare const CustomTypes: t.Type<readonly (string | {
+    id: string;
+    fields: readonly (string | {
+        id: string;
+        customtypes: readonly (string | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                fields: readonly string[];
+            })[];
+        })[];
+    } | {
+        id: string;
+        fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    fields: readonly string[];
+                })[];
+            })[];
+        })[];
+    })[];
+})[], readonly (string | {
+    id: string;
+    fields: readonly (string | {
+        id: string;
+        customtypes: readonly (string | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                fields: readonly string[];
+            })[];
+        })[];
+    } | {
+        id: string;
+        fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    fields: readonly string[];
+                })[];
+            })[];
+        })[];
+    })[];
+})[], unknown>;
+export declare const LinkFieldType = "Link";
+export declare const LinkConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    useAsTitle: t.BooleanC;
+    placeholder: t.StringC;
+    select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+    customtypes: t.Type<readonly (string | {
+        id: string;
+        fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    fields: readonly string[];
+                })[];
+            })[];
+        } | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                customtypes: readonly (string | {
+                    id: string;
+                    fields: readonly (string | {
+                        id: string;
+                        fields: readonly string[];
+                    })[];
+                })[];
+            })[];
+        })[];
+    })[], readonly (string | {
+        id: string;
+        fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    fields: readonly string[];
+                })[];
+            })[];
+        } | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                customtypes: readonly (string | {
+                    id: string;
+                    fields: readonly (string | {
+                        id: string;
+                        fields: readonly string[];
+                    })[];
+                })[];
+            })[];
+        })[];
+    })[], unknown>;
+    masks: t.Type<readonly string[], object, unknown>;
+    tags: t.Type<readonly string[], object, unknown>;
+    allowTargetBlank: t.BooleanC;
+    allowText: t.BooleanC;
+    /**
+     * `repeat` property is used to allow multiple links to be added.
+     * `undefined` means that the field is not repeatable (hence repeat = false).
+     */
+    repeat: t.BooleanC;
+    /**
+     * `variants` allows an option to be picked from a list (e.g. "primary"). To
+     * be considered, the list must have at least one item.
+     */
+    variants: t.ArrayC<t.StringC>;
+}>>;
+export declare type LinkConfig = t.TypeOf<typeof LinkConfig>;
+export declare const Link: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Link">;
+}>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        useAsTitle: t.BooleanC;
+        placeholder: t.StringC;
+        select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+        customtypes: t.Type<readonly (string | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                customtypes: readonly (string | {
+                    id: string;
+                    fields: readonly (string | {
+                        id: string;
+                        fields: readonly string[];
+                    })[];
+                })[];
+            } | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    customtypes: readonly (string | {
+                        id: string;
+                        fields: readonly (string | {
+                            id: string;
+                            fields: readonly string[];
+                        })[];
+                    })[];
+                })[];
+            })[];
+        })[], readonly (string | {
+            id: string;
+            fields: readonly (string | {
+                id: string;
+                customtypes: readonly (string | {
+                    id: string;
+                    fields: readonly (string | {
+                        id: string;
+                        fields: readonly string[];
+                    })[];
+                })[];
+            } | {
+                id: string;
+                fields: readonly (string | {
+                    id: string;
+                    customtypes: readonly (string | {
+                        id: string;
+                        fields: readonly (string | {
+                            id: string;
+                            fields: readonly string[];
+                        })[];
+                    })[];
+                })[];
+            })[];
+        })[], unknown>;
+        masks: t.Type<readonly string[], object, unknown>;
+        tags: t.Type<readonly string[], object, unknown>;
+        allowTargetBlank: t.BooleanC;
+        allowText: t.BooleanC;
+        /**
+         * `repeat` property is used to allow multiple links to be added.
+         * `undefined` means that the field is not repeatable (hence repeat = false).
+         */
+        repeat: t.BooleanC;
+        /**
+         * `variants` allows an option to be picked from a list (e.g. "primary"). To
+         * be considered, the list must have at least one item.
+         */
+        variants: t.ArrayC<t.StringC>;
+    }>>;
+}>]>>;
+export declare type Link = t.TypeOf<typeof Link>;