@prismicio/types-internal 0.2.2 → 0.2.3

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

@@ -1,27 +1,30 @@
-import * as t from "io-ts";
-import { withFallback } from "io-ts-types/lib/withFallback";
-import NestableWidget from "../nestable/NestableWidget";
-import SlicesTypes from "./SlicesTypes";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const withFallback_1 = require("io-ts-types/lib/withFallback");
+const NestableWidget_1 = (0, tslib_1.__importDefault)(require("../nestable/NestableWidget"));
+const SlicesTypes_1 = (0, tslib_1.__importDefault)(require("./SlicesTypes"));
 const IMAGE_PLACEHOLDER_URL = "https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format";
 const Variation = t.exact(t.intersection([
     t.type({
         id: t.string,
         name: t.string,
         description: t.string,
-        imageUrl: withFallback(t.string, IMAGE_PLACEHOLDER_URL),
+        imageUrl: (0, withFallback_1.withFallback)(t.string, IMAGE_PLACEHOLDER_URL),
         docURL: t.string,
         version: t.string,
     }),
     t.partial({
         display: t.string,
-        primary: t.record(t.string, NestableWidget),
-        items: t.record(t.string, NestableWidget),
+        primary: t.record(t.string, NestableWidget_1.default),
+        items: t.record(t.string, NestableWidget_1.default),
     }),
 ]));
 const SharedSlice = t.exact(t.intersection([
     t.type({
         id: t.string,
-        type: t.literal(SlicesTypes.SharedSlice),
+        type: t.literal(SlicesTypes_1.default.SharedSlice),
         name: t.string,
         variations: t.array(Variation),
     }),
@@ -29,4 +32,4 @@ const SharedSlice = t.exact(t.intersection([
         description: t.string,
     }),
 ]));
-export default SharedSlice;
+exports.default = SharedSlice;

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

@@ -1,6 +1,9 @@
-import * as t from "io-ts";
-import SlicesTypes from "./SlicesTypes";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SlicesTypes_1 = (0, tslib_1.__importDefault)(require("./SlicesTypes"));
 const SharedSliceRef = t.exact(t.type({
-    type: t.literal(SlicesTypes.SharedSlice),
+    type: t.literal(SlicesTypes_1.default.SharedSlice),
 }));
-export default SharedSliceRef;
+exports.default = SharedSliceRef;

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

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -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 = (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({
@@ -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.default;
+                    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.js

@@ -1,7 +1,16 @@
-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.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.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.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 = (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
-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.default.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.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);
         }
     },
 };