@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

package/lib/customtypes/widgets/nestable/RichText.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RichText = exports.RichTextConfig = exports.RichTextNodeTypeCodec = exports.RichTextNodeType = exports.DEFAULT_OPTION = exports.RichTextFieldType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts/");
+const Either_1 = require("fp-ts/lib/Either");
+const function_1 = require("fp-ts/lib/function");
+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.RichTextFieldType = "StructuredText";
+exports.DEFAULT_OPTION = "paragraph";
+exports.RichTextNodeType = {
+    heading1: "heading1",
+    heading2: "heading2",
+    heading3: "heading3",
+    heading4: "heading4",
+    heading5: "heading5",
+    heading6: "heading6",
+    paragraph: "paragraph",
+    strong: "strong",
+    em: "em",
+    preformatted: "preformatted",
+    hyperlink: "hyperlink",
+    image: "image",
+    embed: "embed",
+    list: "list-item",
+    orderedList: "o-list-item",
+    rtl: "rtl",
+};
+exports.RichTextNodeTypeCodec = t.keyof({
+    [exports.RichTextNodeType.heading1]: null,
+    [exports.RichTextNodeType.heading2]: null,
+    [exports.RichTextNodeType.heading3]: null,
+    [exports.RichTextNodeType.heading4]: null,
+    [exports.RichTextNodeType.heading5]: null,
+    [exports.RichTextNodeType.heading6]: null,
+    [exports.RichTextNodeType.paragraph]: null,
+    [exports.RichTextNodeType.strong]: null,
+    [exports.RichTextNodeType.em]: null,
+    [exports.RichTextNodeType.preformatted]: null,
+    [exports.RichTextNodeType.hyperlink]: null,
+    [exports.RichTextNodeType.image]: null,
+    [exports.RichTextNodeType.embed]: null,
+    [exports.RichTextNodeType.list]: null,
+    [exports.RichTextNodeType.orderedList]: null,
+    [exports.RichTextNodeType.rtl]: null,
+});
+const RichTextOptions = new t.Type("RichTextOptions", (u) => typeof u === "string", (u) => {
+    return (0, function_1.pipe)(t.union([t.string, t.null]).decode(u), fp_ts_1.either.map((s) => {
+        if (!s)
+            return exports.DEFAULT_OPTION;
+        const entries = s.split(",").map((e) => e.trim());
+        const filtered = entries.filter((entry) => {
+            return (0, Either_1.getOrElseW)(() => undefined)(exports.RichTextNodeTypeCodec.decode(entry));
+        });
+        if (!filtered.length)
+            return exports.DEFAULT_OPTION;
+        return filtered.join(",");
+    }));
+}, (a) => a);
+const NoLabels = (labels) => {
+    if (!labels)
+        return t.success([]);
+    return;
+};
+const LabelsAsObject = (labels) => {
+    if (labels instanceof Object) {
+        const labelsObj = labels;
+        // empty labels
+        if (!Object.entries(labelsObj).length)
+            return t.success([]);
+        // weird case labels with empty key as parent
+        if (labelsObj[""]) {
+            return t.success(labelsObj[""].map((l) => l.name));
+        }
+        const convertedObjectToArray = Object.entries(labelsObj)
+            .reduce((acc, [, labelsEntries]) => {
+            return acc.concat(labelsEntries.map((l) => l.name));
+        }, [])
+            .filter(Boolean);
+        return t.success(convertedObjectToArray);
+    }
+    return;
+};
+const LabelsAsArray = (labels) => {
+    if (labels instanceof Array) {
+        const isValidLabels = labels.reduce((acc, l) => acc && typeof l === "string", true);
+        if (isValidLabels)
+            return t.success(labels);
+    }
+    return;
+};
+const LabelsAsString = (labels) => {
+    if (typeof labels === "string") {
+        return t.success([labels]);
+    }
+    return;
+};
+const RichTextLabels = new t.Type("RichTextLabels", (u) => {
+    return u instanceof Array;
+}, (u, context) => {
+    const legacyValidator = t.record(t.string, t.readonlyArray(t.record(t.literal("name"), t.string)));
+    const validator = t.readonlyArray(t.string);
+    return (0, function_1.pipe)(t.union([legacyValidator, validator, t.string, t.null]).decode(u), fp_ts_1.either.chain((labels) => {
+        return (NoLabels(labels) ||
+            LabelsAsArray(labels) ||
+            LabelsAsObject(labels) ||
+            LabelsAsString(labels) ||
+            t.failure(u, context));
+    }));
+}, (res) => res);
+exports.RichTextConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    useAsTitle: t.boolean,
+    single: RichTextOptions,
+    multi: RichTextOptions,
+    imageConstraint: ImageConstraint_1.default,
+    labels: RichTextLabels,
+    allowTargetBlank: t.boolean,
+}));
+exports.RichText = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.RichTextFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.RichTextConfig,
+    }),
+]));

package/lib/customtypes/widgets/nestable/Select.d.ts

@@ -0,0 +1,21 @@
+import * as t from "io-ts";
+export declare const SelectFieldType = "Select";
+export declare const SelectConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    placeholder: t.StringC;
+    default_value: t.StringC;
+    options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+}>>;
+export declare type SelectConfig = t.TypeOf<typeof SelectConfig>;
+export declare const Select: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Select">;
+}>, 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_value: t.StringC;
+        options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+    }>>;
+}>]>>;
+export declare type Select = t.TypeOf<typeof Select>;

package/lib/customtypes/widgets/nestable/Select.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Select = exports.SelectConfig = exports.SelectFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+exports.SelectFieldType = "Select";
+exports.SelectConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+    placeholder: t.string,
+    default_value: t.string,
+    options: t.readonlyArray(t.union([t.string, validators_1.StringFromNumber, validators_1.StringFromBoolean])),
+}));
+exports.Select = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.SelectFieldType),
+    }),
+    t.partial({
+        fieldset: validators_1.StringOrNull,
+        config: exports.SelectConfig,
+    }),
+]));

package/lib/customtypes/widgets/nestable/Separator.d.ts

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

package/lib/customtypes/widgets/nestable/Separator.js

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

package/lib/customtypes/widgets/nestable/Table.d.ts

@@ -0,0 +1,21 @@
+import * as t from "io-ts";
+export declare const TableFieldType = "Table";
+declare const TableConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>>;
+export declare type TableConfig = t.TypeOf<typeof TableConfig>;
+export declare const Table: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Table">;
+}>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+        label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+}>]>>;
+export declare type Table = t.TypeOf<typeof Table>;
+export declare const TableCell: {
+    type: "StructuredText";
+    config: {
+        multi: string;
+    };
+};
+export {};

package/lib/customtypes/widgets/nestable/Table.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableCell = exports.Table = exports.TableFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const RichText_1 = require("./RichText");
+exports.TableFieldType = "Table";
+const TableConfig = t.exact(t.partial({
+    label: validators_1.StringOrNull,
+}));
+exports.Table = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.TableFieldType),
+    }),
+    t.partial({
+        config: TableConfig,
+    }),
+]));
+exports.TableCell = {
+    type: "StructuredText",
+    config: {
+        multi: [
+            RichText_1.RichTextNodeType.paragraph,
+            RichText_1.RichTextNodeType.strong,
+            RichText_1.RichTextNodeType.em,
+            RichText_1.RichTextNodeType.hyperlink,
+        ].join(","),
+    },
+};

package/lib/customtypes/widgets/nestable/Text.d.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+export declare const TextFieldType = "Text";
+export declare const TextConfig: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    useAsTitle: t.BooleanC;
+    placeholder: t.StringC;
+}>>;
+export declare type TextConfig = t.TypeOf<typeof TextConfig>;
+export declare const Text: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Text">;
+}>, 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;
+    }>>;
+}>]>>;
+export declare type Text = t.TypeOf<typeof Text>;

package/lib/customtypes/widgets/nestable/Text.js

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

package/lib/customtypes/widgets/nestable/Timestamp.d.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+export declare const TimestampFieldType = "Timestamp";
+export declare const TimestampConfig: 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 TimestampConfig = t.TypeOf<typeof TimestampConfig>;
+export declare const Timestamp: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+}>, 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 Timestamp = t.TypeOf<typeof Timestamp>;

package/lib/customtypes/widgets/nestable/Timestamp.js

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

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

@@ -0,0 +1,17 @@
+export * from "./BooleanField";
+export * from "./Color";
+export * from "./Date";
+export * from "./Embed";
+export * from "./GeoPoint";
+export * from "./Image";
+export * from "./IntegrationField";
+export * from "./Link";
+export * from "./NestableWidget";
+export * from "./Number";
+export * from "./Range";
+export * from "./RichText";
+export * from "./Select";
+export * from "./Separator";
+export * from "./Table";
+export * from "./Text";
+export * from "./Timestamp";

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./BooleanField"), exports);
+(0, tslib_1.__exportStar)(require("./Color"), exports);
+(0, tslib_1.__exportStar)(require("./Date"), exports);
+(0, tslib_1.__exportStar)(require("./Embed"), exports);
+(0, tslib_1.__exportStar)(require("./GeoPoint"), exports);
+(0, tslib_1.__exportStar)(require("./Image"), exports);
+(0, tslib_1.__exportStar)(require("./IntegrationField"), exports);
+(0, tslib_1.__exportStar)(require("./Link"), exports);
+(0, tslib_1.__exportStar)(require("./NestableWidget"), exports);
+(0, tslib_1.__exportStar)(require("./Number"), exports);
+(0, tslib_1.__exportStar)(require("./Range"), exports);
+(0, tslib_1.__exportStar)(require("./RichText"), exports);
+(0, tslib_1.__exportStar)(require("./Select"), exports);
+(0, tslib_1.__exportStar)(require("./Separator"), exports);
+(0, tslib_1.__exportStar)(require("./Table"), exports);
+(0, tslib_1.__exportStar)(require("./Text"), exports);
+(0, tslib_1.__exportStar)(require("./Timestamp"), exports);

package/lib/customtypes/widgets/shared/ImageConstraint.d.ts

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+declare const ImageConstraint: t.PartialC<{
+    width: t.Type<number | null, unknown, unknown>;
+    height: t.Type<number | null, unknown, unknown>;
+}>;
+declare type ImageConstraint = t.TypeOf<typeof ImageConstraint>;
+export default ImageConstraint;

package/lib/customtypes/widgets/shared/ImageConstraint.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/lib/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const IntFromString_1 = require("io-ts-types/lib/IntFromString");
+const validators_1 = require("../../../validators");
+const SideConstraint = new t.Type("SideConstraints", (u) => {
+    return !u || typeof u === "number";
+}, (u, context) => {
+    return Either_1.either.chain(t
+        .union([
+        t.literal("auto"),
+        t.literal(""),
+        t.Int,
+        IntFromString_1.IntFromString,
+        validators_1.IntFromNumber,
+        validators_1.IntFromPixels,
+        t.null,
+    ])
+        .validate(u, context), (constraint) => {
+        if (constraint === "auto" || constraint === "")
+            return t.success(null);
+        return t.success(constraint);
+    });
+}, (res) => res);
+const ImageConstraint = t.partial({
+    width: SideConstraint,
+    height: SideConstraint,
+});
+exports.default = ImageConstraint;

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

@@ -0,0 +1 @@
+export { default as ImageConstraint } from "./ImageConstraint";

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

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageConstraint = void 0;
+var ImageConstraint_1 = require("./ImageConstraint");
+Object.defineProperty(exports, "ImageConstraint", { enumerable: true, get: function () { return __importDefault(ImageConstraint_1).default; } });