@prismicio/types-internal 0.1.1 → 0.2.3

package/lib/customtypes/widgets/slices/Slices.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const Format_1 = require("../../Format");
+const WidgetTypes_1 = (0, tslib_1.__importDefault)(require("../WidgetTypes"));
+const CompositeSlice_1 = (0, tslib_1.__importDefault)(require("./CompositeSlice"));
+const LegacySlice_1 = (0, tslib_1.__importDefault)(require("./LegacySlice"));
+const SharedSlice_1 = (0, tslib_1.__importDefault)(require("./SharedSlice"));
+const SharedSliceRef_1 = (0, tslib_1.__importDefault)(require("./SharedSliceRef"));
+const SlicesTypes_1 = (0, tslib_1.__importDefault)(require("./SlicesTypes"));
+const SlicesLabels = t.union([
+    t.record(t.string, t.array(t.exact(t.intersection([
+        t.type({
+            name: t.string,
+        }),
+        t.partial({
+            display: t.string,
+        }),
+    ])))),
+    t.null,
+]);
+function slicesConfigReader(format) {
+    return t.exact(t.partial({
+        label: validators_1.StringOrNull,
+        labels: SlicesLabels,
+        choices: t.record(t.string, t.union([
+            LegacySlice_1.default,
+            CompositeSlice_1.default,
+            (() => {
+                switch (format) {
+                    case Format_1.Format.Static:
+                        return SharedSlice_1.default;
+                    case Format_1.Format.Dynamic:
+                        return SharedSliceRef_1.default;
+                    default:
+                        throw new Error(`Invalid Format Exception: ${format} doesn't exist`);
+                }
+            })(),
+        ])),
+    }));
+}
+exports.slicesConfigReader = slicesConfigReader;
+exports.StaticSlicesConfig = slicesConfigReader(Format_1.Format.Static);
+exports.DynamicSlicesConfig = slicesConfigReader(Format_1.Format.Dynamic);
+const SlicesConfig = {
+    toStatic(config, sharedSlices) {
+        const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
+            if (slice.type === SlicesTypes_1.default.SharedSlice) {
+                const sharedSlice = sharedSlices.get(ref);
+                if (sharedSlice)
+                    return { ...acc, [ref]: sharedSlice };
+                else
+                    return acc;
+            }
+            else {
+                return { ...acc, [ref]: slice };
+            }
+        }, {});
+        return { ...config, choices };
+    },
+};
+function slicesReader(format) {
+    return t.exact(t.intersection([
+        t.type({
+            type: t.union([
+                t.literal(WidgetTypes_1.default.Slices),
+                t.literal(WidgetTypes_1.default.LegacySlices),
+            ]),
+        }),
+        t.partial({
+            fieldset: validators_1.StringOrNull,
+            config: slicesConfigReader(format),
+        }),
+    ]));
+}
+exports.slicesReader = slicesReader;
+exports.StaticSlices = slicesReader(Format_1.Format.Static);
+exports.DynamicSlices = slicesReader(Format_1.Format.Dynamic);
+exports.Slices = {
+    toStatic(slices, sharedSlices) {
+        if (!slices.config)
+            return slices;
+        else {
+            return {
+                ...slices,
+                config: SlicesConfig.toStatic(slices.config, sharedSlices),
+            };
+        }
+    },
+};

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

@@ -0,0 +1,7 @@
+export { default as CompositeSlice } from "./CompositeSlice";
+export { default as LegacySlice } from "./LegacySlice";
+export { default as SharedSlice } from "./SharedSlice";
+export { default as SharedSliceRef } from "./SharedSliceRef";
+export * as Slice from "./Slice";
+export * as SliceZone from "./Slices";
+export { default as SlicesTypes } from "./SlicesTypes";

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlicesTypes = exports.SliceZone = exports.Slice = exports.SharedSliceRef = exports.SharedSlice = exports.LegacySlice = exports.CompositeSlice = void 0;
+const tslib_1 = require("tslib");
+var CompositeSlice_1 = require("./CompositeSlice");
+Object.defineProperty(exports, "CompositeSlice", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(CompositeSlice_1).default; } });
+var LegacySlice_1 = require("./LegacySlice");
+Object.defineProperty(exports, "LegacySlice", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(LegacySlice_1).default; } });
+var SharedSlice_1 = require("./SharedSlice");
+Object.defineProperty(exports, "SharedSlice", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(SharedSlice_1).default; } });
+var SharedSliceRef_1 = require("./SharedSliceRef");
+Object.defineProperty(exports, "SharedSliceRef", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(SharedSliceRef_1).default; } });
+exports.Slice = (0, tslib_1.__importStar)(require("./Slice"));
+exports.SliceZone = (0, tslib_1.__importStar)(require("./Slices"));
+var SlicesTypes_1 = require("./SlicesTypes");
+Object.defineProperty(exports, "SlicesTypes", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(SlicesTypes_1).default; } });

package/lib/documents/DocumentData.d.ts

@@ -0,0 +1,8 @@
+import * as O from "fp-ts/lib/Option";
+import { type WidgetContent, type WidgetKey } from "./widgets";
+declare type DocumentData = Map<WidgetKey, O.Option<WidgetContent>>;
+declare const DocumentData: {
+    getWidget(key: WidgetKey, widgets: Map<WidgetKey, unknown>, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>, parsed: Map<string, O.Option<WidgetContent>>): O.Option<WidgetContent>;
+    fromJson(widgets: Map<WidgetKey, unknown>, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>): DocumentData;
+};
+export default DocumentData;

package/lib/documents/DocumentData.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const O = (0, tslib_1.__importStar)(require("fp-ts/lib/Option"));
+const widgets_1 = require("./widgets");
+function computeWidget(key, widgets, widgetTypes, widgetPositions) {
+    const widget = widgets.get(key);
+    if (widget === undefined) {
+        return O.none;
+    }
+    return widgets_1.Widget.fromJson(key, widget, widgetTypes, widgetPositions);
+}
+const DocumentData = {
+    getWidget(key, widgets, widgetTypes, widgetPositions, parsed) {
+        const widget = parsed.get(key);
+        if (widget === undefined) {
+            return computeWidget(key, widgets, widgetTypes, widgetPositions);
+        }
+        return widget;
+    },
+    fromJson(widgets, widgetTypes, widgetPositions) {
+        return Array.from(widgets.keys()).reduce((acc, widgetKey) => {
+            const parsedWidget = this.getWidget(widgetKey, widgets, widgetTypes, widgetPositions, acc);
+            return new Map([...Array.from(acc.entries()), [widgetKey, parsedWidget]]);
+        }, new Map());
+    },
+};
+exports.default = DocumentData;

package/lib/documents/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DocumentData } from "./DocumentData";
+export * as Widgets from "./widgets";

package/lib/documents/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Widgets = exports.DocumentData = void 0;
+const tslib_1 = require("tslib");
+var DocumentData_1 = require("./DocumentData");
+Object.defineProperty(exports, "DocumentData", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(DocumentData_1).default; } });
+exports.Widgets = (0, tslib_1.__importStar)(require("./widgets"));

package/lib/documents/widgets/EmptyContent.d.ts

@@ -0,0 +1,8 @@
+export declare const EmptyContentType = "EmptyContent";
+export declare type EmptyContent = {
+    type: string;
+    __TYPE__: typeof EmptyContentType;
+};
+export declare const EmptyContent: {
+    is: (value: unknown) => value is EmptyContent;
+};

package/lib/documents/widgets/EmptyContent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyContent = exports.EmptyContentType = void 0;
+exports.EmptyContentType = "EmptyContent";
+exports.EmptyContent = {
+    is: (value) => {
+        return value.__TYPE__ === exports.EmptyContentType;
+    },
+};

package/lib/documents/widgets/GroupContent.d.ts

@@ -0,0 +1,16 @@
+import * as O from "fp-ts/Option";
+import { SimpleWidgetContent } from "./SimpleWidgetContent";
+export declare const GroupItemContentType = "GroupItemContent";
+export interface GroupItemContent {
+    __TYPE__: typeof GroupItemContentType;
+    value: Array<[string, SimpleWidgetContent]>;
+}
+export declare const GroupContentType = "GroupContentType";
+export interface GroupContent {
+    __TYPE__: typeof GroupContentType;
+    value: GroupItemContent[];
+}
+export declare const GroupContent: Readonly<{
+    itemsContentsFromJson: (prefixedKey: string, jsItems: Array<unknown> | undefined, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => Array<GroupItemContent>;
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<GroupContent>;
+}>;

package/lib/documents/widgets/GroupContent.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupContent = exports.GroupContentType = exports.GroupItemContentType = void 0;
+const tslib_1 = require("tslib");
+const A = (0, tslib_1.__importStar)(require("fp-ts/Array"));
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SimpleWidgetContent_1 = require("./SimpleWidgetContent");
+exports.GroupItemContentType = "GroupItemContent";
+exports.GroupContentType = "GroupContentType";
+exports.GroupContent = Object.freeze({
+    itemsContentsFromJson: (prefixedKey, jsItems, fieldTypes, fieldPositions) => {
+        if (jsItems) {
+            return jsItems.map((jsItem) => {
+                if (typeof jsItem === "object" && jsItem !== null) {
+                    const sorted = Object.entries(jsItem).sort(([k1], [k2]) => {
+                        const p1 = fieldPositions.get(`${prefixedKey}.${k1}`) ?? 10000;
+                        const p2 = fieldPositions.get(`${prefixedKey}.${k2}`) ?? 10000;
+                        return p1 - p2;
+                    });
+                    const w = sorted.map(([k, v]) => {
+                        const kind = fieldTypes.get(`${prefixedKey}.${k}`);
+                        if (kind) {
+                            return O.map((content) => {
+                                return [k, content];
+                            })(SimpleWidgetContent_1.SimpleWidgetContent.from(kind, v));
+                        }
+                        else {
+                            return O.none;
+                        }
+                    });
+                    return {
+                        __TYPE__: "GroupItemContent",
+                        value: A.compact(w),
+                    };
+                }
+                else {
+                    return {
+                        __TYPE__: "GroupItemContent",
+                        value: [],
+                    };
+                }
+            });
+        }
+        else {
+            return [];
+        }
+    },
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const prefixedKey = Array.of(prefixes, [key]).flat().join(".");
+        const maybeJsItems = O.fromEither(t.array(t.unknown).decode(value));
+        return O.map((items) => {
+            return {
+                value: exports.GroupContent.itemsContentsFromJson(prefixedKey, items, fieldTypes, fieldPositions),
+                __TYPE__: exports.GroupContentType,
+            };
+        })(maybeJsItems);
+    },
+});

package/lib/documents/widgets/SimpleWidgetContent.d.ts

@@ -0,0 +1,20 @@
+import * as O from "fp-ts/Option";
+import type { EmptyContent } from "./EmptyContent";
+import BooleanContent from "./nestable/BooleanContent";
+import EmbedContent from "./nestable/EmbedContent";
+import FieldContent from "./nestable/FieldContent";
+import { GeoPointContentO } from "./nestable/GeoPointContent";
+import { ImageContentO } from "./nestable/ImageContent";
+import IntegrationFieldsContent from "./nestable/IntegrationFieldsContent";
+import { LinkContent } from "./nestable/Link";
+import type { SeparatorContent } from "./nestable/SeparatorContent";
+import { StructuredTextContent } from "./nestable/StructuredTextContent";
+import { UIDContent } from "./UIDContent";
+export declare const SimpleWidgetContentType: string[];
+export declare type NonEmptySimpleWidgetContent = IntegrationFieldsContent | StructuredTextContent | ImageContentO | GeoPointContentO | EmbedContent | LinkContent | UIDContent | SeparatorContent | FieldContent | BooleanContent;
+export declare type SimpleWidgetContent = NonEmptySimpleWidgetContent | EmptyContent;
+export declare function is(value: unknown): value is SimpleWidgetContent;
+export declare const SimpleWidgetContent: {
+    from: (type: string, content: unknown) => O.Option<SimpleWidgetContent>;
+    is: (value: unknown) => value is SimpleWidgetContent;
+};

package/lib/documents/widgets/SimpleWidgetContent.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleWidgetContent = exports.is = exports.SimpleWidgetContentType = void 0;
+const tslib_1 = require("tslib");
+const function_1 = require("fp-ts/function");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BooleanContent_1 = (0, tslib_1.__importDefault)(require("./nestable/BooleanContent"));
+const EmbedContent_1 = (0, tslib_1.__importDefault)(require("./nestable/EmbedContent"));
+const FieldContent_1 = (0, tslib_1.__importDefault)(require("./nestable/FieldContent"));
+const GeoPointContent_1 = require("./nestable/GeoPointContent");
+const ImageContent_1 = require("./nestable/ImageContent");
+const IntegrationFieldsContent_1 = (0, tslib_1.__importDefault)(require("./nestable/IntegrationFieldsContent"));
+const Link_1 = require("./nestable/Link");
+const StructuredTextContent_1 = require("./nestable/StructuredTextContent");
+const UIDContent_1 = require("./UIDContent");
+//TODO: rework that using import such as EmptyContentType
+exports.SimpleWidgetContentType = [
+    "EmptyContent",
+    "ImageContent",
+    "GeoPointContent",
+    "EmbedContent",
+    "BooleanContent",
+    "IntegrationFieldsContent",
+    "StructuredTextContent",
+    "LinkContent",
+    "UIDContent",
+    "SeparatorContent",
+    "FieldContent",
+];
+function is(value) {
+    const asSwc = value;
+    return exports.SimpleWidgetContentType.includes(asSwc.__TYPE__);
+}
+exports.is = is;
+const valueNullCodec = t.type({
+    value: t.null,
+});
+exports.SimpleWidgetContent = {
+    from: (type, content) => {
+        if (content === null || valueNullCodec.is(content)) {
+            const result = { type: type, __TYPE__: "EmptyContent" };
+            return O.some(result);
+        }
+        switch (type) {
+            case "StructuredText":
+                return O.fromEither(StructuredTextContent_1.StructuredTextContent.decode(content));
+            case "IntegrationFields":
+                return O.fromEither(IntegrationFieldsContent_1.default.decode(content));
+            case "Image":
+                return (0, function_1.pipe)(O.fromEither(ImageContent_1.ImageContent.decode(content)), O.map((imageContent) => ImageContent_1.ImageContent.encode(imageContent)));
+            case "GeoPoint":
+                return (0, function_1.pipe)(O.fromEither(GeoPointContent_1.GeoPointContent.decode(content)), O.map((geopointContent) => GeoPointContent_1.GeoPointContent.encode(geopointContent)));
+            case "Embed":
+                return O.fromEither(EmbedContent_1.default.decode(content));
+            case "Link":
+                return O.fromEither(Link_1.LinkContent.decode(content));
+            case "UID":
+                return O.fromEither(UIDContent_1.UIDContent.decode(content));
+            case "Separator":
+                return O.some({ __TYPE__: "SeparatorContent" });
+            case "Boolean":
+                return O.fromEither(BooleanContent_1.default.decode(content));
+            default:
+                if (FieldContent_1.default.types.includes(type)) {
+                    return FieldContent_1.default.forType(type, content);
+                }
+                else {
+                    return O.none;
+                }
+        }
+    },
+    //TODO: rework that
+    is: (value) => exports.SimpleWidgetContentType.includes(value.__TYPE__),
+};

package/lib/documents/widgets/StaticWidgetContent.d.ts

@@ -0,0 +1,10 @@
+import * as O from "fp-ts/Option";
+import { GroupContent } from "./GroupContent";
+import { NonEmptySimpleWidgetContent, SimpleWidgetContent } from "./SimpleWidgetContent";
+declare type StaticWidgetContent = SimpleWidgetContent | GroupContent;
+export declare type NonEmptyStaticWidgetContent = NonEmptySimpleWidgetContent | GroupContent;
+declare const StaticWidgetContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<StaticWidgetContent>;
+    is: (value: unknown) => value is StaticWidgetContent;
+};
+export default StaticWidgetContent;

package/lib/documents/widgets/StaticWidgetContent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const GroupContent_1 = require("./GroupContent");
+const SimpleWidgetContent_1 = require("./SimpleWidgetContent");
+const StaticWidgetContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const prefixedKey = Array.of(prefixes, [key]).flat().join(".");
+        const type = fieldTypes.get(prefixedKey);
+        if (type === "Group") {
+            return GroupContent_1.GroupContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else if (type) {
+            return SimpleWidgetContent_1.SimpleWidgetContent.from(type, value);
+        }
+        else {
+            return O.none;
+        }
+    },
+    is: (value) => {
+        return (SimpleWidgetContent_1.SimpleWidgetContent.is(value) ||
+            GroupContent_1.GroupContentType === value.__TYPE__);
+    },
+};
+exports.default = StaticWidgetContent;

package/lib/documents/widgets/UIDContent.d.ts

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+export declare type UIDContent = {
+    __TYPE__: "UIDContent";
+    value: string;
+};
+export declare const UIDContentType = "UIDContent";
+export declare const UIDContent: t.Type<UIDContent, string, unknown>;

package/lib/documents/widgets/UIDContent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIDContent = exports.UIDContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.UIDContentType = "UIDContent";
+exports.UIDContent = new t.Type("UIDContent", (u) => u?.__TYPE__ === exports.UIDContentType, (u, c) => Either_1.Chain.chain(t.string.validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: "UIDContent" });
+}), (uidContent) => uidContent.value);

package/lib/documents/widgets/index.d.ts

@@ -0,0 +1,35 @@
+import { SlicesContent } from "./slices/SlicesContent";
+import StaticWidgetContent from "./StaticWidgetContent";
+export * from "./EmptyContent";
+export * from "./GroupContent";
+export * as Nestable from "./nestable";
+export * from "./SimpleWidgetContent";
+export * as Slices from "./slices";
+export { type NonEmptyStaticWidgetContent, default as StaticWidgetContent, } from "./StaticWidgetContent";
+export * from "./UIDContent";
+export declare const WidgetTypes: {
+    Empty: string;
+    UID: string;
+    Group: string;
+    slices: string;
+    Links: {
+        DocumentLink: string;
+        FileLink: string;
+        ExternalLink: string;
+        ImageLink: string;
+        LinkContent: string;
+    };
+    StructuredText: string;
+    Boolean: string;
+    Embed: string;
+    Field: string;
+    GeoPoint: string;
+    Image: string;
+    IntegrationFields: string;
+    Separator: string;
+};
+export declare type WidgetKey = string;
+export declare type WidgetContent = SlicesContent | StaticWidgetContent;
+export declare const Widget: {
+    fromJson(widgetKey: WidgetKey, widgetValue: unknown, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>): import("fp-ts/lib/Option").None | import("fp-ts/lib/Option").Some<StaticWidgetContent> | import("fp-ts/lib/Option").Some<SlicesContent>;
+};

package/lib/documents/widgets/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Widget = exports.WidgetTypes = exports.StaticWidgetContent = exports.Slices = exports.Nestable = void 0;
+const tslib_1 = require("tslib");
+const EmptyContent_1 = require("./EmptyContent");
+const GroupContent_1 = require("./GroupContent");
+const nestable_1 = require("./nestable");
+const SlicesContent_1 = require("./slices/SlicesContent");
+const StaticWidgetContent_1 = (0, tslib_1.__importDefault)(require("./StaticWidgetContent"));
+const UIDContent_1 = require("./UIDContent");
+(0, tslib_1.__exportStar)(require("./EmptyContent"), exports);
+(0, tslib_1.__exportStar)(require("./GroupContent"), exports);
+exports.Nestable = (0, tslib_1.__importStar)(require("./nestable"));
+(0, tslib_1.__exportStar)(require("./SimpleWidgetContent"), exports);
+exports.Slices = (0, tslib_1.__importStar)(require("./slices"));
+var StaticWidgetContent_2 = require("./StaticWidgetContent");
+Object.defineProperty(exports, "StaticWidgetContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(StaticWidgetContent_2).default; } });
+(0, tslib_1.__exportStar)(require("./UIDContent"), exports);
+exports.WidgetTypes = {
+    ...nestable_1.NestableTypes,
+    Empty: EmptyContent_1.EmptyContentType,
+    UID: UIDContent_1.UIDContentType,
+    Group: GroupContent_1.GroupContentType,
+    slices: SlicesContent_1.SlicesContentType,
+};
+exports.Widget = {
+    fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions) {
+        const fieldType = widgetTypes.get(widgetKey);
+        if (fieldType === "Slices") {
+            return SlicesContent_1.SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
+        }
+        else {
+            return StaticWidgetContent_1.default.fromJson([], widgetKey, widgetValue, widgetTypes, widgetPositions);
+        }
+    },
+};

package/lib/documents/widgets/nestable/BooleanContent.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+declare type BooleanContent = {
+    __TYPE__: "BooleanContent";
+    value: boolean;
+};
+export declare const BooleanContentType = "BooleanContent";
+declare const BooleanContent: t.Type<BooleanContent, boolean, unknown>;
+export default BooleanContent;

package/lib/documents/widgets/nestable/BooleanContent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.BooleanContentType = "BooleanContent";
+const BooleanContent = new t.Type("BooleanContent", (u) => u?.__TYPE__ === exports.BooleanContentType, (u, c) => Either_1.Chain.chain(t.boolean.validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: exports.BooleanContentType });
+}), (booleanContent) => t.boolean.encode(booleanContent.value));
+exports.default = BooleanContent;

package/lib/documents/widgets/nestable/EmbedContent.d.ts

@@ -0,0 +1,40 @@
+import * as t from "io-ts";
+export declare const EmbedContentType = "EmbedContent";
+declare type EmbedContent = t.OutputOf<typeof EmbedContentC> & {
+    all: unknown;
+};
+declare const EmbedContent: t.Type<EmbedContent, unknown, unknown>;
+declare const EmbedContentC: t.Type<{
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null;
+    title?: string | null | undefined;
+    author_name?: string | null | undefined;
+    author_url?: string | null | undefined;
+    provider_name?: string | null | undefined;
+    provider_url?: string | null | undefined;
+    cache_age?: string | number | null;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+}, {
+    embed_url: string;
+    type: string;
+} & {
+    version?: string | number | null;
+    title?: string | null | undefined;
+    author_name?: string | null | undefined;
+    author_url?: string | null | undefined;
+    provider_name?: string | null | undefined;
+    provider_url?: string | null | undefined;
+    cache_age?: string | number | null;
+    thumbnail_url?: string | null | undefined;
+    thumbnail_width?: number | null | undefined;
+    thumbnail_height?: number | null | undefined;
+    html?: string | null | undefined;
+} & {
+    __TYPE__: "EmbedContent";
+}, unknown>;
+export default EmbedContent;

package/lib/documents/widgets/nestable/EmbedContent.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const function_2 = require("../../../validators/function");
+exports.EmbedContentType = "EmbedContent";
+const EmbedContent = new t.Type("EmbedContent", (u) => u.__TYPE__ === exports.EmbedContentType, (u) => {
+    return (0, function_1.pipe)(EmbedContentC.decode(u), fp_ts_1.either.map((s) => ({
+        ...EmbedContentC.encode(s),
+        all: u,
+    })));
+}, (ec) => EmbedContentC.encode(ec));
+const EmbedContentC = (0, function_2.addType)(t.exact(t.intersection([
+    t.type({
+        embed_url: t.string,
+        type: t.string,
+    }),
+    t.partial({
+        version: t.union([t.string, t.number, t.null]),
+        title: validators_1.StringOrNull,
+        author_name: validators_1.StringOrNull,
+        author_url: validators_1.StringOrNull,
+        provider_name: validators_1.StringOrNull,
+        provider_url: validators_1.StringOrNull,
+        cache_age: t.union([t.string, t.number, t.null]),
+        thumbnail_url: validators_1.StringOrNull,
+        thumbnail_width: validators_1.NumberOrNull,
+        thumbnail_height: validators_1.NumberOrNull,
+        html: validators_1.StringOrNull,
+    }),
+])), exports.EmbedContentType);
+exports.default = EmbedContent;

package/lib/documents/widgets/nestable/FieldContent.d.ts

@@ -0,0 +1,12 @@
+import * as O from "fp-ts/Option";
+export declare const FieldContentType = "FieldContent";
+declare type FieldContent = {
+    value: string;
+    type: string;
+    __TYPE__: typeof FieldContentType;
+};
+declare const FieldContent: {
+    types: string[];
+    forType: (type: string, value: unknown) => O.Option<FieldContent>;
+};
+export default FieldContent;