@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

package/lib/content/fields/WidgetContent.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetLegacy = exports.isWidgetContent = exports.WidgetContent = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const GroupContent_1 = require("./GroupContent");
+const nestable_1 = require("./nestable");
+const slices_1 = require("./slices");
+const UIDContent_1 = require("./UIDContent");
+exports.WidgetContent = t.union([
+    GroupContent_1.GroupContent,
+    nestable_1.NestableContent,
+    UIDContent_1.UIDContent,
+    slices_1.SlicesContent,
+]);
+const isWidgetContent = (u) => (0, GroupContent_1.isGroupContent)(u) ||
+    (0, nestable_1.isNestableContent)(u) ||
+    (0, UIDContent_1.isUIDContent)(u) ||
+    (0, slices_1.isSlicesContent)(u);
+exports.isWidgetContent = isWidgetContent;
+const WidgetLegacy = (ctx) => {
+    return {
+        decode(value) {
+            if (!ctx.fieldType)
+                return;
+            const codec = (() => {
+                switch (ctx.fieldType) {
+                    case "UID":
+                        return (0, UIDContent_1.UIDLegacy)(ctx);
+                    case "Group":
+                        return (0, GroupContent_1.GroupLegacy)(ctx);
+                    case "Choice":
+                    case "Slices":
+                        return (0, slices_1.SlicesLegacy)(ctx);
+                    default:
+                        return (0, nestable_1.NestableLegacy)(ctx);
+                }
+            })();
+            if (!codec)
+                return;
+            return codec.decode(value);
+        },
+        encode(value) {
+            switch (value.__TYPE__) {
+                case UIDContent_1.UIDContentType:
+                    return (0, UIDContent_1.UIDLegacy)(ctx).encode(value);
+                case GroupContent_1.GroupContentType:
+                    return (0, GroupContent_1.GroupLegacy)(ctx).encode(value);
+                case slices_1.SlicesContentType:
+                    return (0, slices_1.SlicesLegacy)(ctx).encode(value);
+                default:
+                    return (0, nestable_1.NestableLegacy)(ctx).encode(value);
+            }
+        },
+    };
+};
+exports.WidgetLegacy = WidgetLegacy;

package/lib/content/fields/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./EmptyContent";
+export * from "./GroupContent";
+export * from "./nestable";
+export * from "./slices";
+export * from "./UIDContent";
+export * from "./WidgetContent";

package/lib/content/fields/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./EmptyContent"), exports);
+(0, tslib_1.__exportStar)(require("./GroupContent"), exports);
+(0, tslib_1.__exportStar)(require("./nestable"), exports);
+(0, tslib_1.__exportStar)(require("./slices"), exports);
+(0, tslib_1.__exportStar)(require("./UIDContent"), exports);
+(0, tslib_1.__exportStar)(require("./WidgetContent"), exports);

package/lib/content/fields/nestable/BooleanContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { BooleanField } from "../../../customtypes";
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const BooleanContentType = "BooleanContent";
+export declare const isBooleanContent: (u: unknown) => u is {
+    __TYPE__: "BooleanContent";
+    value: boolean;
+};
+export declare const BooleanLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    __TYPE__: "BooleanContent";
+    value: boolean;
+}, WithTypes<boolean>, unknown>;
+export declare const BooleanContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"BooleanContent">;
+    value: t.BooleanC;
+}>>;
+export declare type BooleanContent = t.TypeOf<typeof BooleanContent>;
+export declare const BooleanContentDefaultValue: (field: BooleanField) => BooleanContent | undefined;

package/lib/content/fields/nestable/BooleanContent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanContentDefaultValue = exports.BooleanContent = exports.BooleanLegacy = exports.isBooleanContent = exports.BooleanContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const utils_1 = require("../../utils");
+exports.BooleanContentType = "BooleanContent";
+const isBooleanContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.BooleanContentType;
+exports.isBooleanContent = isBooleanContent;
+const BooleanLegacy = (ctx) => new t.Type("BooleanLegacy", exports.isBooleanContent, (u) => {
+    return (0, function_1.pipe)(t.boolean.decode(u), fp_ts_1.either.map((b) => exports.BooleanContent.encode({ value: b, __TYPE__: exports.BooleanContentType })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: "Boolean" },
+        keys: {},
+    };
+});
+exports.BooleanLegacy = BooleanLegacy;
+exports.BooleanContent = t.strict({
+    __TYPE__: t.literal(exports.BooleanContentType),
+    value: t.boolean,
+});
+const BooleanContentDefaultValue = (field) => {
+    var _a;
+    return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.default_value) !== undefined
+        ? {
+            __TYPE__: exports.BooleanContentType,
+            value: field.config.default_value || false,
+        }
+        : undefined;
+};
+exports.BooleanContentDefaultValue = BooleanContentDefaultValue;

package/lib/content/fields/nestable/EmbedContent.d.ts

@@ -0,0 +1,78 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const EmbedContentType = "EmbedContent";
+export declare const isEmbedContent: (u: unknown) => u is {
+    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";
+    all: unknown;
+};
+export declare const EmbedContentLegacy: t.ExactC<t.IntersectionC<[t.TypeC<{
+    embed_url: t.StringC;
+    type: t.StringC;
+}>, t.PartialC<{
+    version: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    title: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    cache_age: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    thumbnail_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_width: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_height: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    html: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type EmbedLegacy = t.TypeOf<typeof EmbedContentLegacy>;
+export declare const EmbedLegacy: (ctx: LegacyContentCtx) => 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;
+} & {
+    __TYPE__: "EmbedContent";
+    all: unknown;
+}, WithTypes<unknown>, unknown>;
+export declare const EmbedContent: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    embed_url: t.StringC;
+    type: t.StringC;
+}>, t.PartialC<{
+    version: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    title: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    author_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    provider_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    cache_age: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    thumbnail_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_width: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    thumbnail_height: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+    html: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>, t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"EmbedContent">;
+    all: t.UnknownC;
+}>>]>;
+export declare type EmbedContent = t.TypeOf<typeof EmbedContent>;

package/lib/content/fields/nestable/EmbedContent.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedContent = exports.EmbedLegacy = exports.EmbedContentLegacy = exports.isEmbedContent = exports.EmbedContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const utils_1 = require("../../utils");
+exports.EmbedContentType = "EmbedContent";
+const isEmbedContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.EmbedContentType;
+exports.isEmbedContent = isEmbedContent;
+exports.EmbedContentLegacy = 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,
+    }),
+]));
+const EmbedLegacy = (ctx) => new t.Type("EmbedLegacy", exports.isEmbedContent, (u) => {
+    return (0, function_1.pipe)(exports.EmbedContentLegacy.decode(u), fp_ts_1.either.map((embed) => ({
+        ...embed,
+        all: u,
+        __TYPE__: exports.EmbedContentType,
+    })));
+}, (embed) => {
+    return {
+        /**
+         *  we cast here because actually in the all property
+         * we can have extra keys that are never parsed and we don't want to loose them.
+         **/
+        content: embed.all,
+        types: { [ctx.keyOfType]: "Embed" },
+        keys: {},
+    };
+});
+exports.EmbedLegacy = EmbedLegacy;
+exports.EmbedContent = t.intersection([
+    exports.EmbedContentLegacy,
+    t.strict({
+        __TYPE__: t.literal(exports.EmbedContentType),
+        all: t.unknown,
+    }),
+]);

package/lib/content/fields/nestable/FieldContent/ColorContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isColorContent: (u: unknown) => u is {
+    type: "Color";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const ColorLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Color";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const ColorContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Color">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type ColorContent = t.TypeOf<typeof ColorContent>;

package/lib/content/fields/nestable/FieldContent/ColorContent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorContent = exports.ColorLegacy = exports.isColorContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isColorContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Color";
+exports.isColorContent = isColorContent;
+const ColorLegacy = (ctx) => new t.Type("ColorLegacy", exports.isColorContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.ColorContent.encode({
+        value: f,
+        type: widgets_1.ColorFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.ColorFieldType },
+        keys: {},
+    };
+});
+exports.ColorLegacy = ColorLegacy;
+exports.ColorContent = t.strict({
+    type: t.literal(widgets_1.ColorFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/DateContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isDateContent: (u: unknown) => u is {
+    type: "Date";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const DateLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Date";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const DateContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Date">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type DateContent = t.TypeOf<typeof DateContent>;

package/lib/content/fields/nestable/FieldContent/DateContent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateContent = exports.DateLegacy = exports.isDateContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isDateContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Date";
+exports.isDateContent = isDateContent;
+const DateLegacy = (ctx) => new t.Type("DateLegacy", exports.isDateContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.DateContent.encode({
+        value: f,
+        type: widgets_1.DateFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.DateFieldType },
+        keys: {},
+    };
+});
+exports.DateLegacy = DateLegacy;
+exports.DateContent = t.strict({
+    type: t.literal(widgets_1.DateFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/NumberContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isNumberContent: (u: unknown) => u is {
+    type: "Number";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const NumberLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Number";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const NumberContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Number">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type NumberContent = t.TypeOf<typeof NumberContent>;

package/lib/content/fields/nestable/FieldContent/NumberContent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberContent = exports.NumberLegacy = exports.isNumberContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isNumberContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Number";
+exports.isNumberContent = isNumberContent;
+const NumberLegacy = (ctx) => new t.Type("NumberLegacy", exports.isNumberContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.NumberContent.encode({
+        value: f,
+        type: widgets_1.NumberFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.NumberFieldType },
+        keys: {},
+    };
+});
+exports.NumberLegacy = NumberLegacy;
+exports.NumberContent = t.strict({
+    type: t.literal(widgets_1.NumberFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/RangeContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isRangeContent: (u: unknown) => u is {
+    type: "Range";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const RangeLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Range";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const RangeContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Range">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type RangeContent = t.TypeOf<typeof RangeContent>;

package/lib/content/fields/nestable/FieldContent/RangeContent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeContent = exports.RangeLegacy = exports.isRangeContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isRangeContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Range";
+exports.isRangeContent = isRangeContent;
+const RangeLegacy = (ctx) => new t.Type("RangeLegacy", exports.isRangeContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.RangeContent.encode({
+        value: f,
+        type: widgets_1.RangeFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.RangeFieldType },
+        keys: {},
+    };
+});
+exports.RangeLegacy = RangeLegacy;
+exports.RangeContent = t.strict({
+    type: t.literal(widgets_1.RangeFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/SelectContent.d.ts

@@ -0,0 +1,20 @@
+import * as t from "io-ts";
+import { Select } from "../../../../customtypes/widgets";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isSelectContent: (u: unknown) => u is {
+    type: "Select";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const SelectLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Select";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const SelectContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Select">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type SelectContent = t.TypeOf<typeof SelectContent>;
+export declare const SelectContentDefaultValue: (field: Select) => SelectContent | undefined;

package/lib/content/fields/nestable/FieldContent/SelectContent.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectContentDefaultValue = exports.SelectContent = exports.SelectLegacy = exports.isSelectContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isSelectContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Select";
+exports.isSelectContent = isSelectContent;
+const SelectLegacy = (ctx) => new t.Type("SelectLegacy", exports.isSelectContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.SelectContent.encode({
+        value: f,
+        type: widgets_1.SelectFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.SelectFieldType },
+        keys: {},
+    };
+});
+exports.SelectLegacy = SelectLegacy;
+exports.SelectContent = t.strict({
+    type: t.literal(widgets_1.SelectFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});
+const SelectContentDefaultValue = (field) => {
+    var _a;
+    return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.default_value)
+        ? {
+            __TYPE__: common_1.FieldContentType,
+            type: widgets_1.SelectFieldType,
+            value: field.config.default_value || "",
+        }
+        : undefined;
+};
+exports.SelectContentDefaultValue = SelectContentDefaultValue;

package/lib/content/fields/nestable/FieldContent/TextContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isTextContent: (u: unknown) => u is {
+    type: "Text";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const TextLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Text";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const TextContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Text">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type TextContent = t.TypeOf<typeof TextContent>;

package/lib/content/fields/nestable/FieldContent/TextContent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextContent = exports.TextLegacy = exports.isTextContent = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const widgets_1 = require("../../../../customtypes/widgets");
+const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../../validators/TrimmedString"));
+const utils_1 = require("../../../utils");
+const common_1 = require("./common");
+const isTextContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Text";
+exports.isTextContent = isTextContent;
+const TextLegacy = (ctx) => new t.Type("TextLegacy", exports.isTextContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.TextContent.encode({
+        value: f,
+        type: widgets_1.TextFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.TextFieldType },
+        keys: {},
+    };
+});
+exports.TextLegacy = TextLegacy;
+exports.TextContent = t.strict({
+    type: t.literal(widgets_1.TextFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

package/lib/content/fields/nestable/FieldContent/TimestampContent.d.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+export declare const isTimestampContent: (u: unknown) => u is {
+    type: "Timestamp";
+    value: string;
+    __TYPE__: "FieldContent";
+};
+export declare const TimestampLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    type: "Timestamp";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
+export declare const TimestampContent: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>;
+export declare type TimestampContent = t.TypeOf<typeof TimestampContent>;