@prismicio/types-internal 2.0.0-alpha.2 → 2.0.0-alpha.3

package/lib/customtypes/utils/Comparator.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SliceComparator = exports.DiffOperation = void 0;
-const utils_1 = require("../../utils");
-var DiffOperation;
-(function (DiffOperation) {
-    DiffOperation["Added"] = "added";
-    DiffOperation["Removed"] = "removed";
-    DiffOperation["Updated"] = "updated";
-})(DiffOperation = exports.DiffOperation || (exports.DiffOperation = {}));
-function compareSliceMeta(sliceA, sliceB) {
-    const zippedSlices = utils_1.Objects.zipObjects(sliceA, sliceB);
-    return Object.entries(zippedSlices).reduce((acc, [key, value]) => {
-        if (key === `variations`)
-            return acc;
-        if ((value === null || value === void 0 ? void 0 : value.left) === (value === null || value === void 0 ? void 0 : value.right))
-            return acc;
-        return { ...acc, [key]: value === null || value === void 0 ? void 0 : value.right };
-    }, {});
-}
-exports.SliceComparator = {
-    compare(sliceA, sliceB) {
-        if (!sliceA && sliceB)
-            return {
-                op: DiffOperation.Added,
-                value: sliceB,
-            };
-        if (sliceA && !sliceB)
-            return {
-                op: DiffOperation.Removed,
-            };
-        const diffMeta = compareSliceMeta(sliceA, sliceB);
-        const zippedSlices = utils_1.Objects.zipObjects(sliceA && utils_1.Arrays.toRecord(sliceA.variations, (v) => v.id), sliceB && utils_1.Arrays.toRecord(sliceB.variations, (v) => v.id));
-        const diffVariations = Object.entries(zippedSlices).reduce((acc, [variationId, value]) => {
-            if (!value)
-                return acc;
-            const vDiff = VariationComparator.compare(value.left, value.right);
-            if (!vDiff)
-                return acc;
-            return {
-                ...acc,
-                [variationId]: vDiff,
-            };
-        }, {});
-        const diffSlice = {
-            ...diffMeta,
-            ...(utils_1.Objects.isNotEmpty(diffVariations)
-                ? { variations: diffVariations }
-                : {}),
-        };
-        if (utils_1.Objects.isNotEmpty(diffSlice)) {
-            return {
-                op: DiffOperation.Updated,
-                value: diffSlice,
-            };
-        }
-        return undefined;
-    },
-};

package/lib/customtypes/utils/index.d.ts

@@ -1 +0,0 @@
-export * from "./Comparator";

package/lib/customtypes/utils/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./Comparator"), exports);

package/lib/customtypes/widgets/WidgetTypes.d.ts

@@ -1,22 +0,0 @@
-export declare const WidgetTypes: {
-    readonly Text: "Text";
-    readonly RichText: "StructuredText";
-    readonly Color: "Color";
-    readonly Image: "Image";
-    readonly Date: "Date";
-    readonly Timestamp: "Timestamp";
-    readonly Number: "Number";
-    readonly Range: "Range";
-    readonly Select: "Select";
-    readonly Link: "Link";
-    readonly Embed: "Embed";
-    readonly GeoPoint: "GeoPoint";
-    readonly Separator: "Separator";
-    readonly UID: "UID";
-    readonly BooleanField: "Boolean";
-    readonly IntegrationField: "IntegrationFields";
-    readonly Group: "Group";
-    readonly Slices: "Slices";
-    readonly LegacySlices: "Choice";
-};
-export declare type WidgetTypes = typeof WidgetTypes[keyof typeof WidgetTypes];

package/lib/customtypes/widgets/WidgetTypes.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetTypes = void 0;
-exports.WidgetTypes = {
-    Text: "Text",
-    RichText: "StructuredText",
-    Color: "Color",
-    Image: "Image",
-    Date: "Date",
-    Timestamp: "Timestamp",
-    Number: "Number",
-    Range: "Range",
-    Select: "Select",
-    Link: "Link",
-    Embed: "Embed",
-    GeoPoint: "GeoPoint",
-    Separator: "Separator",
-    UID: "UID",
-    BooleanField: "Boolean",
-    IntegrationField: "IntegrationFields",
-    Group: "Group",
-    Slices: "Slices",
-    // Legacy type for slices
-    LegacySlices: "Choice",
-};

package/lib/documents/DocumentData.d.ts

@@ -1,6 +0,0 @@
-import { WidgetContent, WidgetKey } from "../content";
-import type { FieldTypes } from "../customtypes/widgets";
-declare const DocumentData: {
-    getWidget(key: WidgetKey, widgetTypes: Map<WidgetKey, FieldTypes>, parsed: Map<string, WidgetContent>): WidgetContent | undefined;
-};
-export default DocumentData;

package/lib/documents/DocumentData.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const content_1 = require("../content");
-const LegacyContentCtx_1 = require("../content/LegacyContentCtx");
-const DocumentData = {
-    getWidget(key, widgetTypes, parsed) {
-        const widget = parsed.get(key);
-        if (widget === undefined) {
-            const res = (0, content_1.WidgetLegacy)((0, LegacyContentCtx_1.defaultCtx)(key, widgetTypes)).decode(parsed);
-            return !res || res._tag === "Left" ? undefined : res.right;
-        }
-        return widget;
-    },
-};
-exports.default = DocumentData;

package/lib/documents/index.d.ts

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

package/lib/documents/index.js

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

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

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

package/lib/documents/widgets/EmptyContent.js

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

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

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

package/lib/documents/widgets/GroupContent.js

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

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

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

package/lib/documents/widgets/SimpleWidgetContent.js

@@ -1,75 +0,0 @@
-"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
-exports.SimpleWidgetContentType = [
-    "EmptyContent",
-    "ImageContent",
-    "GeoPointContent",
-    "EmbedContent",
-    "BooleanContent",
-    "IntegrationFieldsContent",
-    "StructuredTextContent",
-    "LinkContent",
-    "UIDContent",
-    "SeparatorContent",
-    "FieldContent",
-];
-function is(value) {
-    const asSwc = value;
-    return exports.SimpleWidgetContentType.includes(asSwc.__TYPE__);
-}
-exports.is = is;
-const valueNullCodec = t.type({
-    value: t.null,
-});
-exports.SimpleWidgetContent = {
-    from: (type, content) => {
-        if (content === null || valueNullCodec.is(content)) {
-            const result = { type: type, __TYPE__: "EmptyContent" };
-            return O.some(result);
-        }
-        switch (type) {
-            case "StructuredText":
-                return O.fromEither(StructuredTextContent_1.StructuredTextContent.decode(content));
-            case "IntegrationFields":
-                return O.fromEither(IntegrationFieldsContent_1.default.decode(content));
-            case "Image":
-                return (0, function_1.pipe)(O.fromEither(ImageContent_1.ImageContent.decode(content)), O.map((imageContent) => ImageContent_1.ImageContent.encode(imageContent)));
-            case "GeoPoint":
-                return (0, function_1.pipe)(O.fromEither(GeoPointContent_1.GeoPointContent.decode(content)), O.map((geopointContent) => GeoPointContent_1.GeoPointContent.encode(geopointContent)));
-            case "Embed":
-                return O.fromEither(EmbedContent_1.EmbedContent.decode(content));
-            case "Link":
-                return O.fromEither(Link_1.LinkContent.decode(content));
-            case "UID":
-                return O.fromEither(UIDContent_1.UIDContent.decode(content));
-            case "Separator":
-                return O.some({ __TYPE__: "SeparatorContent" });
-            case "Boolean":
-                return O.fromEither(BooleanContent_1.default.decode(content));
-            default:
-                if (FieldContent_1.default.types.includes(type)) {
-                    return FieldContent_1.default.forType(type, content);
-                }
-                else {
-                    return O.none;
-                }
-        }
-    },
-    //TODO: rework that
-    is: (value) => exports.SimpleWidgetContentType.includes(value.__TYPE__),
-};

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

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

package/lib/documents/widgets/StaticWidgetContent.js

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

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

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

package/lib/documents/widgets/UIDContent.js

@@ -1,10 +0,0 @@
-"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) => { var _a; return ((_a = u) === null || _a === void 0 ? void 0 : _a.__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

@@ -1,38 +0,0 @@
-import * as t from "io-ts";
-import { SlicesContent } from "./slices";
-import StaticWidgetContent from "./StaticWidgetContent";
-export * from "./EmptyContent";
-export * from "./GroupContent";
-export * as Nestable from "./nestable";
-export * from "./SimpleWidgetContent";
-export * as Slices from "./slices";
-export { type NonEmptyStaticWidgetContent, default as StaticWidgetContent, } from "./StaticWidgetContent";
-export * from "./UIDContent";
-export declare const WidgetTypes: {
-    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";
-    };
-    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 WidgetTypes = typeof WidgetTypes[keyof typeof WidgetTypes];
-export declare const WidgetKey: t.Type<string, string, unknown>;
-export declare type WidgetKey = t.TypeOf<typeof WidgetKey>;
-export declare type WidgetContent = SlicesContent | StaticWidgetContent;
-export declare const Widget: {
-    fromJson(widgetKey: WidgetKey, widgetValue: unknown, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>): import("fp-ts/lib/Option").None | import("fp-ts/lib/Option").Some<StaticWidgetContent> | import("fp-ts/lib/Option").Some<SlicesContent>;
-};

package/lib/documents/widgets/index.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Widget = exports.WidgetKey = exports.WidgetTypes = exports.StaticWidgetContent = exports.Slices = exports.Nestable = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const function_1 = require("../../validators/function");
-const EmptyContent_1 = require("./EmptyContent");
-const GroupContent_1 = require("./GroupContent");
-const nestable_1 = require("./nestable");
-const slices_1 = require("./slices");
-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: slices_1.SlicesContentType,
-};
-const widgetKeyRegex = new RegExp("^[^<>]+$");
-exports.WidgetKey = (0, function_1.refineType)(t.string, "WidgetKey", (s) => s.length === 0 || widgetKeyRegex.test(s));
-exports.Widget = {
-    fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions) {
-        const fieldType = widgetTypes.get(widgetKey);
-        if (fieldType === "Slices") {
-            return slices_1.SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
-        }
-        else {
-            return StaticWidgetContent_1.default.fromJson([], widgetKey, widgetValue, widgetTypes, widgetPositions);
-        }
-    },
-};

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

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

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

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-import * as O from "fp-ts/Option";
-export declare type FieldType = "Text" | "Date" | "Timestamp" | "Color" | "Number" | "Range" | "Select";
-export declare const FieldContentType = "FieldContent";
-declare type FieldContent = {
-    value: string;
-    type: FieldType;
-    __TYPE__: typeof FieldContentType;
-};
-declare const FieldContent: {
-    types: string[];
-    forType: (type: FieldType, value: unknown) => O.Option<FieldContent>;
-};
-export default FieldContent;

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldContentType = 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"));
-exports.FieldContentType = "FieldContent";
-//we do that instead of idiomatic .trim()
-//because we need to have the exact same behaviour than scala/java .trim()
-//in other world only trim space and not non-breaking space or tab
-function trimScalaStyle(s) {
-    let startAt = 0;
-    /* eslint-disable  @typescript-eslint/no-non-null-assertion */
-    while (startAt < s.length && s[startAt] <= " ") {
-        startAt++;
-    }
-    let endAt = s.length;
-    /* eslint-disable  @typescript-eslint/no-non-null-assertion */
-    while (startAt < endAt && s[endAt - 1] <= " ") {
-        endAt--;
-    }
-    return s.substring(startAt, endAt);
-}
-const FieldContent = {
-    types: ["Text", "Date", "Timestamp", "Color", "Number", "Range", "Select"],
-    forType: (type, value) => {
-        return (0, function_1.pipe)(O.fromEither(t.string.decode(value)), O.map((r) => {
-            return {
-                value: trimScalaStyle(r),
-                type,
-                __TYPE__: "FieldContent",
-            };
-        }));
-    },
-};
-exports.default = FieldContent;