@prismicio/types-internal 0.2.2 → 0.2.6

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

@@ -1,7 +1,7 @@
 import * as t from "io-ts";
 import { Format } from "../../Format";
 import WidgetTypes from "../WidgetTypes";
-import SharedSlice from "./SharedSlice";
+import { SharedSlice } from "./SharedSlice";
 import SlicesTypes from "./SlicesTypes";
 export declare function slicesConfigReader<F extends Format>(format: F): t.ExactC<t.PartialC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -10,16 +10,7 @@ export declare function slicesConfigReader<F extends Format>(format: F): t.Exact
     }>, t.PartialC<{
         display: t.StringC;
     }>]>>>>, t.NullC]>;
-    choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-        type: t.LiteralC<WidgetTypes.UID>;
-    }>, 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;
-        }>>;
-    }>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
         type: t.LiteralC<WidgetTypes.Color>;
     }>, t.PartialC<{
         fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -1007,16 +998,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
     }>, t.PartialC<{
         display: t.StringC;
     }>]>>>>, t.NullC]>;
-    choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-        type: t.LiteralC<WidgetTypes.UID>;
-    }>, 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;
-        }>>;
-    }>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
         type: t.LiteralC<WidgetTypes.Color>;
     }>, t.PartialC<{
         fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -2005,16 +1987,7 @@ export declare const DynamicSlicesConfig: t.ExactC<t.PartialC<{
     }>, t.PartialC<{
         display: t.StringC;
     }>]>>>>, t.NullC]>;
-    choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-        type: t.LiteralC<WidgetTypes.UID>;
-    }>, 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;
-        }>>;
-    }>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
         type: t.LiteralC<WidgetTypes.Color>;
     }>, t.PartialC<{
         fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -3007,16 +2980,7 @@ export declare function slicesReader<F extends Format>(format: F): t.ExactC<t.In
         }>, t.PartialC<{
             display: t.StringC;
         }>]>>>>, t.NullC]>;
-        choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-            type: t.LiteralC<WidgetTypes.UID>;
-        }>, 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;
-            }>>;
-        }>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<WidgetTypes.Color>;
         }>, t.PartialC<{
             fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -4009,16 +3973,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
         }>, t.PartialC<{
             display: t.StringC;
         }>]>>>>, t.NullC]>;
-        choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-            type: t.LiteralC<WidgetTypes.UID>;
-        }>, 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;
-            }>>;
-        }>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<WidgetTypes.Color>;
         }>, t.PartialC<{
             fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -5012,16 +4967,7 @@ export declare const DynamicSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
         }>, t.PartialC<{
             display: t.StringC;
         }>]>>>>, t.NullC]>;
-        choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-            type: t.LiteralC<WidgetTypes.UID>;
-        }>, 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;
-            }>>;
-        }>]>>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        choices: t.RecordC<t.StringC, t.UnionC<[t.UnionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<WidgetTypes.Color>;
         }>, t.PartialC<{
             fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;

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

@@ -1,12 +1,16 @@
-import * as t from "io-ts";
-import { StringOrNull } from "../../../validators";
-import { Format } from "../../Format";
-import WidgetTypes from "../WidgetTypes";
-import CompositeSlice from "./CompositeSlice";
-import LegacySlice from "./LegacySlice";
-import SharedSlice from "./SharedSlice";
-import SharedSliceRef from "./SharedSliceRef";
-import SlicesTypes from "./SlicesTypes";
+"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 = 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({
@@ -18,19 +22,19 @@ const SlicesLabels = t.union([
     ])))),
     t.null,
 ]);
-export function slicesConfigReader(format) {
+function slicesConfigReader(format) {
     return t.exact(t.partial({
-        label: StringOrNull,
+        label: validators_1.StringOrNull,
         labels: SlicesLabels,
         choices: t.record(t.string, t.union([
-            LegacySlice,
-            CompositeSlice,
+            LegacySlice_1.default,
+            CompositeSlice_1.default,
             (() => {
                 switch (format) {
-                    case Format.Static:
-                        return SharedSlice;
-                    case Format.Dynamic:
-                        return SharedSliceRef;
+                    case Format_1.Format.Static:
+                        return SharedSlice_1.SharedSlice;
+                    case Format_1.Format.Dynamic:
+                        return SharedSliceRef_1.default;
                     default:
                         throw new Error(`Invalid Format Exception: ${format} doesn't exist`);
                 }
@@ -38,12 +42,13 @@ export function slicesConfigReader(format) {
         ])),
     }));
 }
-export const StaticSlicesConfig = slicesConfigReader(Format.Static);
-export const DynamicSlicesConfig = slicesConfigReader(Format.Dynamic);
+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.SharedSlice) {
+            if (slice.type === SlicesTypes_1.default.SharedSlice) {
                 const sharedSlice = sharedSlices.get(ref);
                 if (sharedSlice)
                     return { ...acc, [ref]: sharedSlice };
@@ -57,23 +62,24 @@ const SlicesConfig = {
         return { ...config, choices };
     },
 };
-export function slicesReader(format) {
+function slicesReader(format) {
     return t.exact(t.intersection([
         t.type({
             type: t.union([
-                t.literal(WidgetTypes.Slices),
-                t.literal(WidgetTypes.LegacySlices),
+                t.literal(WidgetTypes_1.default.Slices),
+                t.literal(WidgetTypes_1.default.LegacySlices),
             ]),
         }),
         t.partial({
-            fieldset: StringOrNull,
+            fieldset: validators_1.StringOrNull,
             config: slicesConfigReader(format),
         }),
     ]));
 }
-export const StaticSlices = slicesReader(Format.Static);
-export const DynamicSlices = slicesReader(Format.Dynamic);
-export const Slices = {
+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;

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

@@ -1,6 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 var SlicesTypes;
 (function (SlicesTypes) {
     SlicesTypes["Slice"] = "Slice";
     SlicesTypes["SharedSlice"] = "SharedSlice";
 })(SlicesTypes || (SlicesTypes = {}));
-export default SlicesTypes;
+exports.default = SlicesTypes;

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

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

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

@@ -1,7 +1,15 @@
-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";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlicesTypes = exports.SliceZone = exports.Slice = exports.SharedSliceRef = 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; } });
+(0, tslib_1.__exportStar)(require("./SharedSlice"), exports);
+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.js

@@ -1,11 +1,14 @@
-import * as O from "fp-ts/lib/Option";
-import { Widget } from "./widgets";
+"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 Widget.fromJson(key, widget, widgetTypes, widgetPositions);
+    return widgets_1.Widget.fromJson(key, widget, widgetTypes, widgetPositions);
 }
 const DocumentData = {
     getWidget(key, widgets, widgetTypes, widgetPositions, parsed) {
@@ -22,4 +25,4 @@ const DocumentData = {
         }, new Map());
     },
 };
-export default DocumentData;
+exports.default = DocumentData;

package/lib/documents/index.js

@@ -1,2 +1,7 @@
-export { default as DocumentData } from "./DocumentData";
-export * as Widgets from "./widgets";
+"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.js

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

package/lib/documents/widgets/GroupContent.js

@@ -1,10 +1,14 @@
-import * as A from "fp-ts/Array";
-import * as O from "fp-ts/Option";
-import * as t from "io-ts";
-import { SimpleWidgetContent } from "./SimpleWidgetContent";
-export const GroupItemContentType = "GroupItemContent";
-export const GroupContentType = "GroupContentType";
-export const GroupContent = Object.freeze({
+"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) => {
@@ -19,7 +23,7 @@ export const GroupContent = Object.freeze({
                         if (kind) {
                             return O.map((content) => {
                                 return [k, content];
-                            })(SimpleWidgetContent.from(kind, v));
+                            })(SimpleWidgetContent_1.SimpleWidgetContent.from(kind, v));
                         }
                         else {
                             return O.none;
@@ -47,8 +51,8 @@ export const GroupContent = Object.freeze({
         const maybeJsItems = O.fromEither(t.array(t.unknown).decode(value));
         return O.map((items) => {
             return {
-                value: GroupContent.itemsContentsFromJson(prefixedKey, items, fieldTypes, fieldPositions),
-                __TYPE__: GroupContentType,
+                value: exports.GroupContent.itemsContentsFromJson(prefixedKey, items, fieldTypes, fieldPositions),
+                __TYPE__: exports.GroupContentType,
             };
         })(maybeJsItems);
     },

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

@@ -1,7 +1,7 @@
 import * as O from "fp-ts/Option";
 import type { EmptyContent } from "./EmptyContent";
 import BooleanContent from "./nestable/BooleanContent";
-import EmbedContent from "./nestable/EmbedContent";
+import { EmbedContentO } from "./nestable/EmbedContent";
 import FieldContent from "./nestable/FieldContent";
 import { GeoPointContentO } from "./nestable/GeoPointContent";
 import { ImageContentO } from "./nestable/ImageContent";
@@ -11,7 +11,7 @@ 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 NonEmptySimpleWidgetContent = IntegrationFieldsContent | StructuredTextContent | ImageContentO | GeoPointContentO | EmbedContentO | LinkContent | UIDContent | SeparatorContent | FieldContent | BooleanContent;
 export declare type SimpleWidgetContent = NonEmptySimpleWidgetContent | EmptyContent;
 export declare function is(value: unknown): value is SimpleWidgetContent;
 export declare const SimpleWidgetContent: {

package/lib/documents/widgets/SimpleWidgetContent.js

@@ -1,17 +1,21 @@
-import { pipe } from "fp-ts/function";
-import * as O from "fp-ts/Option";
-import * as t from "io-ts";
-import BooleanContent from "./nestable/BooleanContent";
-import EmbedContent from "./nestable/EmbedContent";
-import FieldContent from "./nestable/FieldContent";
-import { GeoPointContent } from "./nestable/GeoPointContent";
-import { ImageContent } from "./nestable/ImageContent";
-import IntegrationFieldsContent from "./nestable/IntegrationFieldsContent";
-import { LinkContent } from "./nestable/Link";
-import { StructuredTextContent } from "./nestable/StructuredTextContent";
-import { UIDContent } from "./UIDContent";
+"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 = 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
-export const SimpleWidgetContentType = [
+exports.SimpleWidgetContentType = [
     "EmptyContent",
     "ImageContent",
     "GeoPointContent",
@@ -24,14 +28,15 @@ export const SimpleWidgetContentType = [
     "SeparatorContent",
     "FieldContent",
 ];
-export function is(value) {
+function is(value) {
     const asSwc = value;
-    return SimpleWidgetContentType.includes(asSwc.__TYPE__);
+    return exports.SimpleWidgetContentType.includes(asSwc.__TYPE__);
 }
+exports.is = is;
 const valueNullCodec = t.type({
     value: t.null,
 });
-export const SimpleWidgetContent = {
+exports.SimpleWidgetContent = {
     from: (type, content) => {
         if (content === null || valueNullCodec.is(content)) {
             const result = { type: type, __TYPE__: "EmptyContent" };
@@ -39,26 +44,26 @@ export const SimpleWidgetContent = {
         }
         switch (type) {
             case "StructuredText":
-                return O.fromEither(StructuredTextContent.decode(content));
+                return O.fromEither(StructuredTextContent_1.StructuredTextContent.decode(content));
             case "IntegrationFields":
-                return O.fromEither(IntegrationFieldsContent.decode(content));
+                return O.fromEither(IntegrationFieldsContent_1.default.decode(content));
             case "Image":
-                return pipe(O.fromEither(ImageContent.decode(content)), O.map((imageContent) => ImageContent.encode(imageContent)));
+                return (0, function_1.pipe)(O.fromEither(ImageContent_1.ImageContent.decode(content)), O.map((imageContent) => ImageContent_1.ImageContent.encode(imageContent)));
             case "GeoPoint":
-                return pipe(O.fromEither(GeoPointContent.decode(content)), O.map((geopointContent) => GeoPointContent.encode(geopointContent)));
+                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.decode(content));
+                return O.fromEither(EmbedContent_1.EmbedContent.decode(content));
             case "Link":
-                return O.fromEither(LinkContent.decode(content));
+                return O.fromEither(Link_1.LinkContent.decode(content));
             case "UID":
-                return O.fromEither(UIDContent.decode(content));
+                return O.fromEither(UIDContent_1.UIDContent.decode(content));
             case "Separator":
                 return O.some({ __TYPE__: "SeparatorContent" });
             case "Boolean":
-                return O.fromEither(BooleanContent.decode(content));
+                return O.fromEither(BooleanContent_1.default.decode(content));
             default:
-                if (FieldContent.types.includes(type)) {
-                    return FieldContent.forType(type, content);
+                if (FieldContent_1.default.types.includes(type)) {
+                    return FieldContent_1.default.forType(type, content);
                 }
                 else {
                     return O.none;
@@ -66,5 +71,5 @@ export const SimpleWidgetContent = {
         }
     },
     //TODO: rework that
-    is: (value) => SimpleWidgetContentType.includes(value.__TYPE__),
+    is: (value) => exports.SimpleWidgetContentType.includes(value.__TYPE__),
 };

package/lib/documents/widgets/StaticWidgetContent.js

@@ -1,23 +1,26 @@
-import * as O from "fp-ts/Option";
-import { GroupContent, GroupContentType } from "./GroupContent";
-import { SimpleWidgetContent, } from "./SimpleWidgetContent";
+"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.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+            return GroupContent_1.GroupContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
         }
         else if (type) {
-            return SimpleWidgetContent.from(type, value);
+            return SimpleWidgetContent_1.SimpleWidgetContent.from(type, value);
         }
         else {
             return O.none;
         }
     },
     is: (value) => {
-        return (SimpleWidgetContent.is(value) ||
-            GroupContentType === value.__TYPE__);
+        return (SimpleWidgetContent_1.SimpleWidgetContent.is(value) ||
+            GroupContent_1.GroupContentType === value.__TYPE__);
     },
 };
-export default StaticWidgetContent;
+exports.default = StaticWidgetContent;

package/lib/documents/widgets/UIDContent.js

@@ -1,6 +1,10 @@
-import { Chain } from "fp-ts/Either";
-import * as t from "io-ts";
-export const UIDContentType = "UIDContent";
-export const UIDContent = new t.Type("UIDContent", (u) => u?.__TYPE__ === UIDContentType, (u, c) => Chain.chain(t.string.validate(u, c), (u) => {
+"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

@@ -8,25 +8,25 @@ 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;
+    readonly Empty: "EmptyContent";
+    readonly UID: "UIDContent";
+    readonly Group: "GroupContentType";
+    readonly slices: "SliceContentType";
+    readonly Links: {
+        readonly DocumentLink: "DocumentLink";
+        readonly FileLink: "FileLink";
+        readonly ExternalLink: "ExternalLink";
+        readonly ImageLink: "ImageLink";
+        readonly LinkContent: "LinkContent";
     };
-    StructuredText: string;
-    Boolean: string;
-    Embed: string;
-    Field: string;
-    GeoPoint: string;
-    Image: string;
-    IntegrationFields: string;
-    Separator: string;
+    readonly StructuredText: "StructuredTextContent";
+    readonly Boolean: "BooleanContent";
+    readonly Embed: "EmbedContent";
+    readonly Field: "FieldContent";
+    readonly GeoPoint: "GeoPointContent";
+    readonly Image: "ImageContent";
+    readonly IntegrationFields: "IntegrationFieldsContent";
+    readonly Separator: "SeparatorContent";
 };
 export declare type WidgetKey = string;
 export declare type WidgetContent = SlicesContent | StaticWidgetContent;

package/lib/documents/widgets/index.js

@@ -1,31 +1,36 @@
-import { EmptyContentType } from "./EmptyContent";
-import { GroupContentType } from "./GroupContent";
-import { NestableTypes } from "./nestable";
-import { SlicesContent, SlicesContentType } from "./slices/SlicesContent";
-import StaticWidgetContent from "./StaticWidgetContent";
-import { UIDContentType } from "./UIDContent";
-export * from "./EmptyContent";
-export * from "./GroupContent";
-export * as Nestable from "./nestable";
-export * from "./SimpleWidgetContent";
-export * as Slices from "./slices";
-export { default as StaticWidgetContent, } from "./StaticWidgetContent";
-export * from "./UIDContent";
-export const WidgetTypes = {
-    ...NestableTypes,
-    Empty: EmptyContentType,
-    UID: UIDContentType,
-    Group: GroupContentType,
-    slices: SlicesContentType,
+"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,
 };
-export const Widget = {
+exports.Widget = {
     fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions) {
         const fieldType = widgetTypes.get(widgetKey);
         if (fieldType === "Slices") {
-            return SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
+            return SlicesContent_1.SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
         }
         else {
-            return StaticWidgetContent.fromJson([], widgetKey, widgetValue, widgetTypes, widgetPositions);
+            return StaticWidgetContent_1.default.fromJson([], widgetKey, widgetValue, widgetTypes, widgetPositions);
         }
     },
 };