@prismicio/types-internal 0.1.1 → 0.2.0

package/lib/documents/widgets/nestable/StructuredTextContent/Block.js

@@ -0,0 +1,118 @@
+"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.Block = exports.TextBlock = exports.checkEmbedBlock = exports.EmbedBlock = exports.EmbedBlockType = exports.checkImageBlock = exports.ImageBlock = exports.ImageBlockType = exports.ValidatedMetas = exports.Meta = void 0;
+const E = __importStar(require("fp-ts/lib/Either"));
+const t = __importStar(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+const EmbedContent_1 = __importDefault(require("../EmbedContent"));
+const ImageContent_1 = require("../ImageContent");
+const Link_1 = require("../Link");
+exports.Meta = t.exact(t.intersection([
+    t.partial({
+        data: t.unknown,
+    }),
+    t.type({
+        start: t.number,
+        end: t.number,
+        type: t.string,
+    }),
+]));
+exports.ValidatedMetas = new t.Type("ValidatedMetas", (metas) => Array.isArray(metas) && metas.every(exports.Meta.is), (metas, c) => {
+    if (Array.isArray(metas)) {
+        const res = metas
+            .reduce((acc, maybeMeta) => {
+            const maybeDecodedMeta = exports.Meta.decode(maybeMeta);
+            if (E.isRight(maybeDecodedMeta)) {
+                const meta = maybeDecodedMeta.right;
+                // if it's an hyperlink it should have data validated as link otherwise we don't care and keep the meta
+                if ((meta.data &&
+                    meta.type === "hyperlink" &&
+                    E.isRight(Link_1.Link.validate(meta.data, c))) ||
+                    meta.type !== "hyperlink") {
+                    return [...acc, meta];
+                }
+            }
+            return acc;
+        }, [])
+            .sort((m1, m2) => m1.start - m2.start);
+        return t.success(res);
+    }
+    else
+        return t.failure(metas, c);
+}, (m) => t.array(exports.Meta).encode(m));
+exports.ImageBlockType = "image";
+exports.ImageBlock = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.ImageBlockType),
+        data: t.intersection([
+            ImageContent_1.ImageContentView,
+            t.partial({
+                linkTo: (0, function_1.nullable)(Link_1.Link),
+            }),
+        ]),
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+function checkImageBlock(block) {
+    return block.type === exports.ImageBlockType;
+}
+exports.checkImageBlock = checkImageBlock;
+exports.EmbedBlockType = "embed";
+exports.EmbedBlock = t.exact(t.intersection([
+    t.type({
+        type: t.literal(exports.EmbedBlockType),
+        data: EmbedContent_1.default,
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+function checkEmbedBlock(block) {
+    return block.type === exports.EmbedBlockType;
+}
+exports.checkEmbedBlock = checkEmbedBlock;
+exports.TextBlock = t.exact(t.intersection([
+    t.type({
+        type: (0, function_1.refineType)(t.string, `string which isn't ${exports.ImageBlockType} ${exports.EmbedBlockType}`, (s) => s !== exports.ImageBlockType && s !== exports.EmbedBlockType),
+        content: t.intersection([
+            t.type({
+                text: t.string,
+            }),
+            t.partial({
+                spans: exports.ValidatedMetas,
+            }),
+        ]),
+    }),
+    t.partial({
+        label: t.string,
+        direction: t.string,
+    }),
+]));
+exports.Block = t.union([exports.ImageBlock, exports.EmbedBlock, exports.TextBlock]);

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

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+import { Block } from "./Block";
+export declare const StructuredTextContentType = "StructuredTextContent";
+export declare type StructuredTextContent = {
+    value: Block[];
+    __TYPE__: typeof StructuredTextContentType;
+};
+export declare const StructuredTextContent: t.Type<StructuredTextContent, string, unknown>;
+export * as Blocks from "./Block";

package/lib/documents/widgets/nestable/StructuredTextContent/index.js

@@ -0,0 +1,32 @@
+"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.Blocks = exports.StructuredTextContent = exports.StructuredTextContentType = void 0;
+const Either_1 = require("fp-ts/Either");
+const t = __importStar(require("io-ts"));
+const Block_1 = require("./Block");
+exports.StructuredTextContentType = "StructuredTextContent";
+exports.StructuredTextContent = new t.Type(exports.StructuredTextContentType, (u) => u?.__TYPE__ === exports.StructuredTextContentType, (u, c) => Either_1.Chain.chain(t.array(Block_1.Block).validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: exports.StructuredTextContentType });
+}), () => {
+    throw new Error("NotImplementedError: Not relevant method");
+});
+exports.Blocks = __importStar(require("./Block"));

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

@@ -0,0 +1,26 @@
+export { default as BooleanContent } from "./BooleanContent";
+export { default as EmbedContent } from "./EmbedContent";
+export { default as FieldContent } from "./FieldContent";
+export { GeoPointContent, GeoPointContentO } from "./GeoPointContent";
+export { ImageContent, ImageContentO, ImageContentView } from "./ImageContent";
+export { default as IntegrationFieldsContent } from "./IntegrationFieldsContent";
+export * as Links from "./Link";
+export * from "./SeparatorContent";
+export * from "./StructuredTextContent";
+export declare const NestableTypes: {
+    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;
+};

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

@@ -0,0 +1,64 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestableTypes = exports.Links = exports.IntegrationFieldsContent = exports.ImageContentView = exports.ImageContent = exports.GeoPointContent = exports.FieldContent = exports.EmbedContent = exports.BooleanContent = void 0;
+const BooleanContent_1 = require("./BooleanContent");
+const EmbedContent_1 = require("./EmbedContent");
+const FieldContent_1 = require("./FieldContent");
+const GeoPointContent_1 = require("./GeoPointContent");
+const ImageContent_1 = require("./ImageContent");
+const IntegrationFieldsContent_1 = require("./IntegrationFieldsContent");
+const Link_1 = require("./Link");
+const SeparatorContent_1 = require("./SeparatorContent");
+const StructuredTextContent_1 = require("./StructuredTextContent");
+var BooleanContent_2 = require("./BooleanContent");
+Object.defineProperty(exports, "BooleanContent", { enumerable: true, get: function () { return __importDefault(BooleanContent_2).default; } });
+var EmbedContent_2 = require("./EmbedContent");
+Object.defineProperty(exports, "EmbedContent", { enumerable: true, get: function () { return __importDefault(EmbedContent_2).default; } });
+var FieldContent_2 = require("./FieldContent");
+Object.defineProperty(exports, "FieldContent", { enumerable: true, get: function () { return __importDefault(FieldContent_2).default; } });
+var GeoPointContent_2 = require("./GeoPointContent");
+Object.defineProperty(exports, "GeoPointContent", { enumerable: true, get: function () { return GeoPointContent_2.GeoPointContent; } });
+var ImageContent_2 = require("./ImageContent");
+Object.defineProperty(exports, "ImageContent", { enumerable: true, get: function () { return ImageContent_2.ImageContent; } });
+Object.defineProperty(exports, "ImageContentView", { enumerable: true, get: function () { return ImageContent_2.ImageContentView; } });
+var IntegrationFieldsContent_2 = require("./IntegrationFieldsContent");
+Object.defineProperty(exports, "IntegrationFieldsContent", { enumerable: true, get: function () { return __importDefault(IntegrationFieldsContent_2).default; } });
+exports.Links = __importStar(require("./Link"));
+__exportStar(require("./SeparatorContent"), exports);
+__exportStar(require("./StructuredTextContent"), exports);
+exports.NestableTypes = {
+    Links: Link_1.LinksTypes,
+    StructuredText: StructuredTextContent_1.StructuredTextContentType,
+    Boolean: BooleanContent_1.BooleanContentType,
+    Embed: EmbedContent_1.EmbedContentType,
+    Field: FieldContent_1.FieldContentType,
+    GeoPoint: GeoPointContent_1.GeoPointContentType,
+    Image: ImageContent_1.ImageContentType,
+    IntegrationFields: IntegrationFieldsContent_1.IntegrationFieldsContentType,
+    Separator: SeparatorContent_1.SeparatorContentType,
+};

package/lib/documents/widgets/slices/CompositeSliceContent.d.ts

@@ -0,0 +1,14 @@
+import * as O from "fp-ts/Option";
+import { GroupItemContent } from "../GroupContent";
+import { SimpleWidgetContent } from "../index";
+export declare const CompositeSliceContentType = "CompositeSliceContent";
+export declare type CompositeSliceContent = {
+    repeat: GroupItemContent[];
+    nonRepeat: {
+        [key: string]: SimpleWidgetContent;
+    };
+    __TYPE__: typeof CompositeSliceContentType;
+};
+export declare const CompositeSliceContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<CompositeSliceContent>;
+};

package/lib/documents/widgets/slices/CompositeSliceContent.js

@@ -0,0 +1,68 @@
+"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.CompositeSliceContent = exports.CompositeSliceContentType = void 0;
+const Either_1 = require("fp-ts/Either");
+const O = __importStar(require("fp-ts/Option"));
+const t = __importStar(require("io-ts"));
+const index_1 = require("../index");
+exports.CompositeSliceContentType = "CompositeSliceContent";
+const codec = t.exact(t.partial({
+    repeat: t.array(t.unknown),
+    "non-repeat": t.UnknownRecord,
+}));
+exports.CompositeSliceContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const prefixedRepeatKey = Array.of(prefixes, [key, "repeat"])
+            .flat()
+            .join(".");
+        const decodedValue = codec.decode(value);
+        if ((0, Either_1.isRight)(decodedValue)) {
+            const repeatObj = decodedValue.right.repeat;
+            const nonRepeatObj = decodedValue.right["non-repeat"] ?? {};
+            const groupItemsContentsRepeat = index_1.GroupContent.itemsContentsFromJson(prefixedRepeatKey, repeatObj, fieldTypes, fieldPositions);
+            const sortedFields = Object.entries(nonRepeatObj).sort(([k1], [k2]) => {
+                const p1 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`) ?? 10000;
+                const p2 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`) ?? 10000;
+                return p1 - p2;
+            });
+            const nonRepeat = sortedFields.reduce((acc, [k, v]) => {
+                const kp = Array.of(prefixes, [key, "non-repeat", k]).flat().join(".");
+                const kind = fieldTypes.get(kp);
+                if (kind) {
+                    const mWidgetContent = index_1.SimpleWidgetContent.from(kind, v);
+                    if (O.isSome(mWidgetContent)) {
+                        acc[k] = mWidgetContent.value;
+                    }
+                }
+                return acc;
+            }, {});
+            return O.some({
+                repeat: groupItemsContentsRepeat,
+                nonRepeat,
+                __TYPE__: "CompositeSliceContent",
+            });
+        }
+        else {
+            return O.none;
+        }
+    },
+};

package/lib/documents/widgets/slices/SharedSliceContent.d.ts

@@ -0,0 +1,15 @@
+import * as O from "fp-ts/Option";
+import { GroupItemContent } from "../GroupContent";
+import { SimpleWidgetContent } from "../index";
+export declare const SharedSliceContentType = "SharedSliceContent";
+export declare type SharedSliceContent = {
+    variation: string;
+    primary: {
+        [key: string]: SimpleWidgetContent;
+    };
+    items: GroupItemContent[];
+    __TYPE__: typeof SharedSliceContentType;
+};
+export declare const SharedSliceContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<SharedSliceContent>;
+};

package/lib/documents/widgets/slices/SharedSliceContent.js

@@ -0,0 +1,80 @@
+"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.SharedSliceContent = exports.SharedSliceContentType = void 0;
+const Either_1 = require("fp-ts/Either");
+const O = __importStar(require("fp-ts/Option"));
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const index_1 = require("../index");
+exports.SharedSliceContentType = "SharedSliceContent";
+const codec = t.exact(t.type({
+    variation: t.string,
+    items: (0, io_ts_types_1.withFallback)(t.array(t.unknown), []),
+    primary: (0, io_ts_types_1.withFallback)(t.UnknownRecord, {}),
+}));
+exports.SharedSliceContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const r = (0, Either_1.map)((v) => {
+            const prefixedItemsKey = Array.of(prefixes, [
+                key,
+                "variations",
+                v.variation,
+                "items",
+            ])
+                .flat()
+                .join(".");
+            const groupItemsContents = index_1.GroupContent.itemsContentsFromJson(prefixedItemsKey, v.items, fieldTypes, fieldPositions);
+            const sortedFields = Object.entries(v.primary).sort(([k1], [k2]) => {
+                const p1 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`) ?? 10000;
+                const p2 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`) ?? 10000;
+                return p1 - p2;
+            });
+            const primary = sortedFields.reduce((acc, [k, w]) => {
+                const kp = Array.of(prefixes, [
+                    key,
+                    "variations",
+                    v.variation,
+                    "primary",
+                    k,
+                ])
+                    .flat()
+                    .join(".");
+                const kind = fieldTypes.get(kp);
+                if (kind) {
+                    const maybeWidgetContent = index_1.SimpleWidgetContent.from(kind, w);
+                    if (O.isSome(maybeWidgetContent)) {
+                        acc[k] = maybeWidgetContent.value;
+                    }
+                }
+                return acc;
+            }, {});
+            const result = {
+                variation: v.variation,
+                primary,
+                items: groupItemsContents,
+                __TYPE__: "SharedSliceContent",
+            };
+            return result;
+        })(codec.decode(value));
+        return O.fromEither(r);
+    },
+};

package/lib/documents/widgets/slices/SimpleSliceContent.d.ts

@@ -0,0 +1,6 @@
+import StaticWidgetContent from "../StaticWidgetContent";
+export declare type SimpleSliceContent = StaticWidgetContent;
+export declare const SimpleSliceContent: {
+    fromJson: (prefixes: string[], key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => import("fp-ts/lib/Option").Option<StaticWidgetContent>;
+    is: (value: unknown) => value is StaticWidgetContent;
+};

package/lib/documents/widgets/slices/SimpleSliceContent.js

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

package/lib/documents/widgets/slices/SliceWidgetContent.d.ts

@@ -0,0 +1,8 @@
+import * as O from "fp-ts/Option";
+import { CompositeSliceContent } from "./CompositeSliceContent";
+import { SharedSliceContent } from "./SharedSliceContent";
+import { SimpleSliceContent } from "./SimpleSliceContent";
+export declare type SliceWidgetContent = SimpleSliceContent | CompositeSliceContent | SharedSliceContent;
+export declare const SliceWidgetContent: {
+    fromJson: (prefixes: Array<string>, key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<SliceWidgetContent>;
+};

package/lib/documents/widgets/slices/SliceWidgetContent.js

@@ -0,0 +1,47 @@
+"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.SliceWidgetContent = void 0;
+const O = __importStar(require("fp-ts/Option"));
+const StaticWidgetContent_1 = __importDefault(require("../StaticWidgetContent"));
+const CompositeSliceContent_1 = require("./CompositeSliceContent");
+const SharedSliceContent_1 = require("./SharedSliceContent");
+exports.SliceWidgetContent = {
+    fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
+        const prefixedKey = Array.of(prefixes, [key]).flat().join(".");
+        const fieldType = fieldTypes.get(prefixedKey);
+        if (fieldType === "SharedSlice") {
+            return SharedSliceContent_1.SharedSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else if (fieldType === "Slice") {
+            return CompositeSliceContent_1.CompositeSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else if (fieldType) {
+            return StaticWidgetContent_1.default.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+        }
+        else {
+            return O.none;
+        }
+    },
+};

package/lib/documents/widgets/slices/SlicesContent.d.ts

@@ -0,0 +1,17 @@
+import * as O from "fp-ts/Option";
+import { SliceWidgetContent } from "./SliceWidgetContent";
+export declare type SlicesContentItem = {
+    key: string;
+    name: string;
+    maybeLabel: string | undefined;
+    widget: SliceWidgetContent;
+};
+export declare const SlicesContentType = "SliceContentType";
+export declare type SlicesContent = {
+    __TYPE__: typeof SlicesContentType;
+    value: SlicesContentItem[];
+};
+export declare const SlicesContent: {
+    itemsCodec: (value: unknown, codecWidget: (n: string, v: unknown) => O.Option<SliceWidgetContent>) => O.Option<SlicesContentItem>;
+    fromJson: (key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<SlicesContent>;
+};

package/lib/documents/widgets/slices/SlicesContent.js

@@ -0,0 +1,69 @@
+"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.SlicesContent = exports.SlicesContentType = void 0;
+const A = __importStar(require("fp-ts/Array"));
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const t = __importStar(require("io-ts"));
+const function_2 = require("../../../validators/function");
+const SliceWidgetContent_1 = require("./SliceWidgetContent");
+exports.SlicesContentType = "SliceContentType";
+const codec = t.exact(t.intersection([
+    t.type({
+        key: t.string,
+        value: t.unknown,
+    }),
+    t.partial({
+        label: (0, function_2.nullable)(t.string),
+    }),
+]));
+exports.SlicesContent = {
+    itemsCodec: (value, codecWidget) => {
+        return (0, function_1.pipe)(codec.decode(value), O.fromEither, O.chain((r) => {
+            const stopIdx = r.key.indexOf("$");
+            const name = r.key.substring(0, stopIdx > 0 ? stopIdx : undefined);
+            const maybeWidget = codecWidget(name, r.value);
+            return O.map((widget) => {
+                return {
+                    key: r.key,
+                    name,
+                    maybeLabel: r.label ?? undefined,
+                    widget: widget,
+                };
+            })(maybeWidget);
+        }));
+    },
+    fromJson: (key, value, fieldTypes, fieldPositions) => {
+        if (fieldTypes.get(key) === "Slices") {
+            const jsItems = O.getOrElse(() => new Array())(O.fromEither(t.array(t.unknown).decode(value)));
+            const widgetCodec = (name, wValue) => SliceWidgetContent_1.SliceWidgetContent.fromJson([key], name, wValue, fieldTypes, fieldPositions);
+            return O.some({
+                value: A.compact(jsItems.map((jsItem) => exports.SlicesContent.itemsCodec(jsItem, widgetCodec))),
+                __TYPE__: exports.SlicesContentType,
+            });
+        }
+        else {
+            console.error("fieldTypes.get(key) !== 'Slices'");
+            return O.none;
+        }
+    },
+};

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

@@ -0,0 +1,5 @@
+export * from "./CompositeSliceContent";
+export * from "./SharedSliceContent";
+export * from "./SimpleSliceContent";
+export * from "./SlicesContent";
+export * from "./SliceWidgetContent";

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

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CompositeSliceContent"), exports);
+__exportStar(require("./SharedSliceContent"), exports);
+__exportStar(require("./SimpleSliceContent"), exports);
+__exportStar(require("./SlicesContent"), exports);
+__exportStar(require("./SliceWidgetContent"), exports);

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * as CustomTypes from "./customtypes";
+export * as Documents from "./documents";
+export * as Validators from "./validators";

package/lib/index.js

@@ -0,0 +1,25 @@
+"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.Validators = exports.Documents = exports.CustomTypes = void 0;
+exports.CustomTypes = __importStar(require("./customtypes"));
+exports.Documents = __importStar(require("./documents"));
+exports.Validators = __importStar(require("./validators"));

package/lib/validators/DateFromString.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, string, unknown>;
+export default _default;