@prismicio/types-internal 0.1.1 → 0.2.0

package/{dist → lib}/customtypes/widgets/slices/Slices.js

@@ -24,40 +24,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = void 0;
 const t = __importStar(require("io-ts"));
-const StringOrNull_1 = require("../../../validators/StringOrNull");
-const WidgetTypes_1 = __importDefault(require("../WidgetTypes"));
+const validators_1 = require("../../../validators");
 const Format_1 = require("../../Format");
-const LegacySlice_1 = __importDefault(require("./LegacySlice"));
+const WidgetTypes_1 = __importDefault(require("../WidgetTypes"));
 const CompositeSlice_1 = __importDefault(require("./CompositeSlice"));
-const SharedSliceRef_1 = __importDefault(require("./SharedSliceRef"));
+const LegacySlice_1 = __importDefault(require("./LegacySlice"));
 const SharedSlice_1 = __importDefault(require("./SharedSlice"));
+const SharedSliceRef_1 = __importDefault(require("./SharedSliceRef"));
 const SlicesTypes_1 = __importDefault(require("./SlicesTypes"));
 const SlicesLabels = t.union([
     t.record(t.string, t.array(t.exact(t.intersection([
         t.type({
-            name: t.string
+            name: t.string,
         }),
         t.partial({
-            display: t.string
-        })
+            display: t.string,
+        }),
     ])))),
-    t.null
+    t.null,
 ]);
 function slicesConfigReader(format) {
     return t.exact(t.partial({
-        label: StringOrNull_1.StringOrNull,
+        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`);
+                    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;
@@ -65,8 +68,7 @@ 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]) => {
+        const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
             if (slice.type === SlicesTypes_1.default.SharedSlice) {
                 const sharedSlice = sharedSlices.get(ref);
                 if (sharedSlice)
@@ -79,17 +81,20 @@ const SlicesConfig = {
             }
         }, {});
         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)])
+            type: t.union([
+                t.literal(WidgetTypes_1.default.Slices),
+                t.literal(WidgetTypes_1.default.LegacySlices),
+            ]),
         }),
         t.partial({
-            fieldset: StringOrNull_1.StringOrNull,
-            config: slicesConfigReader(format)
-        })
+            fieldset: validators_1.StringOrNull,
+            config: slicesConfigReader(format),
+        }),
     ]));
 }
 exports.slicesReader = slicesReader;
@@ -100,7 +105,10 @@ exports.Slices = {
         if (!slices.config)
             return slices;
         else {
-            return { ...slices, config: SlicesConfig.toStatic(slices.config, sharedSlices) };
+            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/{dist → lib}/customtypes/widgets/slices/index.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SliceZone = exports.Slice = exports.SlicesTypes = exports.SharedSliceRef = exports.SharedSlice = exports.LegacySlice = exports.CompositeSlice = void 0;
+exports.SlicesTypes = exports.SliceZone = exports.Slice = exports.SharedSliceRef = exports.SharedSlice = exports.LegacySlice = exports.CompositeSlice = void 0;
 var CompositeSlice_1 = require("./CompositeSlice");
 Object.defineProperty(exports, "CompositeSlice", { enumerable: true, get: function () { return __importDefault(CompositeSlice_1).default; } });
 var LegacySlice_1 = require("./LegacySlice");
@@ -31,7 +31,7 @@ var SharedSlice_1 = require("./SharedSlice");
 Object.defineProperty(exports, "SharedSlice", { enumerable: true, get: function () { return __importDefault(SharedSlice_1).default; } });
 var SharedSliceRef_1 = require("./SharedSliceRef");
 Object.defineProperty(exports, "SharedSliceRef", { enumerable: true, get: function () { return __importDefault(SharedSliceRef_1).default; } });
-var SlicesTypes_1 = require("./SlicesTypes");
-Object.defineProperty(exports, "SlicesTypes", { enumerable: true, get: function () { return __importDefault(SlicesTypes_1).default; } });
 exports.Slice = __importStar(require("./Slice"));
 exports.SliceZone = __importStar(require("./Slices"));
+var SlicesTypes_1 = require("./SlicesTypes");
+Object.defineProperty(exports, "SlicesTypes", { enumerable: true, get: function () { return __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,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const O = __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,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Widgets = exports.DocumentData = void 0;
+var DocumentData_1 = require("./DocumentData");
+Object.defineProperty(exports, "DocumentData", { enumerable: true, get: function () { return __importDefault(DocumentData_1).default; } });
+exports.Widgets = __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,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupContent = exports.GroupContentType = exports.GroupItemContentType = void 0;
+const A = __importStar(require("fp-ts/Array"));
+const O = __importStar(require("fp-ts/Option"));
+const t = __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 { 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 { 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,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleWidgetContent = exports.is = exports.SimpleWidgetContentType = void 0;
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const t = __importStar(require("io-ts"));
+const BooleanContent_1 = __importDefault(require("./nestable/BooleanContent"));
+const EmbedContent_1 = __importDefault(require("./nestable/EmbedContent"));
+const FieldContent_1 = __importDefault(require("./nestable/FieldContent"));
+const GeoPointContent_1 = require("./nestable/GeoPointContent");
+const ImageContent_1 = require("./nestable/ImageContent");
+const IntegrationFieldsContent_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,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const O = __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,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIDContent = exports.UIDContentType = void 0;
+const Either_1 = require("fp-ts/Either");
+const t = __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/Widget.js

@@ -0,0 +1 @@
+"use strict";

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>;
+};