@prismicio/types-internal 1.5.3 → 2.0.0-alpha.0

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

@@ -0,0 +1,49 @@
+import * as t from "io-ts";
+export declare const FieldType: t.KeyofC<{
+    Text: null;
+    Date: null;
+    Timestamp: null;
+    Color: null;
+    Number: null;
+    Range: null;
+    Select: null;
+}>;
+export declare type FieldType = t.TypeOf<typeof FieldType>;
+export declare const FieldContent: t.UnionC<[t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Date">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>, t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Color">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>, t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Number">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>, t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Range">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>, t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Select">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>, t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Text">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>, t.ExactC<t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+    value: t.Type<string, string, unknown>;
+    __TYPE__: t.LiteralC<"FieldContent">;
+}>>]>;
+export declare type FieldContent = t.TypeOf<typeof FieldContent>;
+export * from "./ColorContent";
+export * from "./common";
+export * from "./DateContent";
+export * from "./NumberContent";
+export * from "./RangeContent";
+export * from "./SelectContent";
+export * from "./TextContent";
+export * from "./TimestampContent";

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContent = exports.FieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const ColorContent_1 = require("./ColorContent");
+const DateContent_1 = require("./DateContent");
+const NumberContent_1 = require("./NumberContent");
+const RangeContent_1 = require("./RangeContent");
+const SelectContent_1 = require("./SelectContent");
+const TextContent_1 = require("./TextContent");
+const TimestampContent_1 = require("./TimestampContent");
+exports.FieldType = t.keyof({
+    Text: null,
+    Date: null,
+    Timestamp: null,
+    Color: null,
+    Number: null,
+    Range: null,
+    Select: null,
+});
+exports.FieldContent = t.union([
+    DateContent_1.DateContent,
+    ColorContent_1.ColorContent,
+    NumberContent_1.NumberContent,
+    RangeContent_1.RangeContent,
+    SelectContent_1.SelectContent,
+    TextContent_1.TextContent,
+    TimestampContent_1.TimestampContent,
+]);
+(0, tslib_1.__exportStar)(require("./ColorContent"), exports);
+(0, tslib_1.__exportStar)(require("./common"), exports);
+(0, tslib_1.__exportStar)(require("./DateContent"), exports);
+(0, tslib_1.__exportStar)(require("./NumberContent"), exports);
+(0, tslib_1.__exportStar)(require("./RangeContent"), exports);
+(0, tslib_1.__exportStar)(require("./SelectContent"), exports);
+(0, tslib_1.__exportStar)(require("./TextContent"), exports);
+(0, tslib_1.__exportStar)(require("./TimestampContent"), exports);

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

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const FieldContentType = "FieldContent";
 export declare const FieldType: t.KeyofC<{
     Text: null;
     Date: null;
@@ -9,6 +11,11 @@ export declare const FieldType: t.KeyofC<{
     Select: null;
 }>;
 export declare type FieldType = t.TypeOf<typeof FieldType>;
+export declare const FieldLegacy: (type: FieldType, ctx: LegacyContentCtx) => t.Type<{
+    type: "Color" | "Date" | "Number" | "Range" | "Select" | "Text" | "Timestamp";
+    value: string;
+    __TYPE__: "FieldContent";
+}, WithTypes<string>, unknown>;
 export declare const FieldContent: t.ExactC<t.TypeC<{
     type: t.KeyofC<{
         Text: null;
@@ -23,4 +30,3 @@ export declare const FieldContent: t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"FieldContent">;
 }>>;
 export declare type FieldContent = t.TypeOf<typeof FieldContent>;
-export declare const FieldContentType = "FieldContent";

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

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldContentType = exports.FieldContent = exports.FieldType = void 0;
+exports.FieldContent = exports.FieldLegacy = exports.FieldType = exports.FieldContentType = 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 FieldContent_1 = require("../../../documents/widgets/nestable/FieldContent");
 const TrimmedString_1 = (0, tslib_1.__importDefault)(require("../../../validators/TrimmedString"));
+const utils_1 = require("../../utils");
+exports.FieldContentType = "FieldContent";
 exports.FieldType = t.keyof({
     Text: null,
     Date: null,
@@ -14,9 +17,21 @@ exports.FieldType = t.keyof({
     Range: null,
     Select: null,
 });
+const FieldLegacy = (type, ctx) => new t.Type("FieldLegacy", (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.FieldContentType, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.FieldContent.encode({
+        value: f,
+        type,
+        __TYPE__: exports.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: type },
+    };
+});
+exports.FieldLegacy = FieldLegacy;
 exports.FieldContent = t.strict({
     type: exports.FieldType,
     value: TrimmedString_1.default,
-    __TYPE__: t.literal(FieldContent_1.FieldContentType),
+    __TYPE__: t.literal(exports.FieldContentType),
 });
-exports.FieldContentType = FieldContent_1.FieldContentType;

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

@@ -1,18 +1,33 @@
 import * as t from "io-ts";
-export declare const GeoPointContent: t.IntersectionC<[t.Type<{
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const GeoPointContentType = "GeoPointContent";
+export declare const isGeoPointContent: (u: unknown) => u is {
     position: {
         lat: number;
         lng: number;
     };
-}, {
+} & {
+    __TYPE__: "GeoPointContent";
+};
+export declare const GeoPointLegacy: (ctx: LegacyContentCtx) => t.Type<{
     position: {
         lat: number;
         lng: number;
     };
 } & {
     __TYPE__: "GeoPointContent";
-}, unknown>, t.ExactC<t.TypeC<{
+}, WithTypes<{
+    position: {
+        lat: number;
+        lng: number;
+    };
+}>, unknown>;
+export declare const GeoPointContent: t.IntersectionC<[t.ExactC<t.TypeC<{
+    position: t.ExactC<t.TypeC<{
+        lat: t.NumberC;
+        lng: t.NumberC;
+    }>>;
+}>>, t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"GeoPointContent">;
 }>>]>;
 export declare type GeoPointContent = t.TypeOf<typeof GeoPointContent>;
-export declare const GeoPointContentType = "GeoPointContent";

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

@@ -1,13 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeoPointContentType = exports.GeoPointContent = void 0;
+exports.GeoPointContent = exports.GeoPointLegacy = exports.isGeoPointContent = exports.GeoPointContentType = 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 GeoPointContent_1 = require("../../../documents/widgets/nestable/GeoPointContent");
+const utils_1 = require("../../utils");
+exports.GeoPointContentType = "GeoPointContent";
+const isGeoPointContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.GeoPointContentType;
+exports.isGeoPointContent = isGeoPointContent;
+const legacyReader = t.strict({
+    position: t.strict({
+        lat: t.number,
+        lng: t.number,
+    }),
+});
+const GeoPointLegacy = (ctx) => new t.Type("GeoPointLegacy", exports.isGeoPointContent, (u) => {
+    return (0, function_1.pipe)(legacyReader.decode(u), fp_ts_1.either.map((geo) => exports.GeoPointContent.encode({ ...geo, __TYPE__: exports.GeoPointContentType })));
+}, (geo) => ({
+    content: { position: geo.position },
+    types: { [ctx.keyOfType]: "GeoPoint" },
+}));
+exports.GeoPointLegacy = GeoPointLegacy;
 exports.GeoPointContent = t.intersection([
-    GeoPointContent_1.GeoPointContent,
+    legacyReader,
     t.strict({
-        __TYPE__: t.literal(GeoPointContent_1.GeoPointContentType),
+        __TYPE__: t.literal(exports.GeoPointContentType),
     }),
 ]);
-exports.GeoPointContentType = GeoPointContent_1.GeoPointContentType;

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

@@ -1,6 +1,7 @@
 import * as t from "io-ts";
-import { ImageContentView as view } from "../../../documents/widgets/nestable/ImageContent";
-export declare const ImageContent: t.IntersectionC<[t.Type<{
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const ImageContentType = "ImageContent";
+export declare const isImageContent: (u: unknown) => u is {
     origin: {
         id: string;
         url: string;
@@ -48,7 +49,34 @@ export declare const ImageContent: t.IntersectionC<[t.Type<{
             provider?: string | null | undefined;
         };
     };
-}, {
+} & {
+    __TYPE__: "ImageContent";
+};
+export declare const ImageContentView: t.ExactC<t.IntersectionC<[t.TypeC<{
+    origin: t.ExactC<t.TypeC<{
+        id: t.StringC;
+        url: t.StringC;
+        width: t.NumberC;
+        height: t.NumberC;
+    }>>;
+    width: t.NumberC;
+    height: t.NumberC;
+    edit: t.TypeC<{
+        zoom: t.NumberC;
+        crop: t.TypeC<{
+            x: t.NumberC;
+            y: t.NumberC;
+        }>;
+        background: t.StringC;
+    }>;
+}>, t.PartialC<{
+    url: t.StringC;
+    credits: t.Type<string | null, string | null, unknown>;
+    alt: t.Type<string | null, string | null, unknown>;
+    provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type ImageContentView = t.TypeOf<typeof ImageContentView>;
+export declare const ImageLegacy: (ctx: LegacyContentCtx) => t.Type<{
     origin: {
         id: string;
         url: string;
@@ -98,12 +126,56 @@ export declare const ImageContent: t.IntersectionC<[t.Type<{
     };
 } & {
     __TYPE__: "ImageContent";
-}, unknown>, t.ExactC<t.TypeC<{
-    __TYPE__: t.LiteralC<"ImageContent">;
-}>>]>;
-export declare type ImageContent = t.TypeOf<typeof ImageContent>;
-export declare const ImageContentType = "ImageContent";
-export declare const ImageContentView: t.ExactC<t.IntersectionC<[t.TypeC<{
+}, WithTypes<{
+    origin: {
+        id: string;
+        url: string;
+        width: number;
+        height: number;
+    };
+    width: number;
+    height: number;
+    edit: {
+        zoom: number;
+        crop: {
+            x: number;
+            y: number;
+        };
+        background: string;
+    };
+} & {
+    url?: string;
+    credits?: string | null;
+    alt?: string | null;
+    provider?: string | null | undefined;
+} & {
+    thumbnails?: {
+        [x: string]: {
+            origin: {
+                id: string;
+                url: string;
+                width: number;
+                height: number;
+            };
+            width: number;
+            height: number;
+            edit: {
+                zoom: number;
+                crop: {
+                    x: number;
+                    y: number;
+                };
+                background: string;
+            };
+        } & {
+            url?: string;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | undefined;
+        };
+    };
+}>, unknown>;
+export declare const ImageContent: t.IntersectionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
     origin: t.ExactC<t.TypeC<{
         id: t.StringC;
         url: t.StringC;
@@ -125,5 +197,31 @@ export declare const ImageContentView: t.ExactC<t.IntersectionC<[t.TypeC<{
     credits: t.Type<string | null, string | null, unknown>;
     alt: t.Type<string | null, string | null, unknown>;
     provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
-}>]>>;
-export declare type ImageContentView = view;
+}>]>>, t.PartialC<{
+    thumbnails: t.RecordC<t.StringC, t.ExactC<t.IntersectionC<[t.TypeC<{
+        origin: t.ExactC<t.TypeC<{
+            id: t.StringC;
+            url: t.StringC;
+            width: t.NumberC;
+            height: t.NumberC;
+        }>>;
+        width: t.NumberC;
+        height: t.NumberC;
+        edit: t.TypeC<{
+            zoom: t.NumberC;
+            crop: t.TypeC<{
+                x: t.NumberC;
+                y: t.NumberC;
+            }>;
+            background: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        url: t.StringC;
+        credits: t.Type<string | null, string | null, unknown>;
+        alt: t.Type<string | null, string | null, unknown>;
+        provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>>;
+}>]>, t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"ImageContent">;
+}>>]>;
+export declare type ImageContent = t.TypeOf<typeof ImageContent>;

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

@@ -1,14 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageContentView = exports.ImageContentType = exports.ImageContent = void 0;
+exports.ImageContent = exports.ImageLegacy = exports.ImageContentView = exports.isImageContent = exports.ImageContentType = 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 ImageContent_1 = require("../../../documents/widgets/nestable/ImageContent");
+const Objects_1 = require("../../../utils/Objects");
+const validators_1 = require("../../../validators");
+const utils_1 = require("../../utils");
+exports.ImageContentType = "ImageContent";
+const isImageContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.ImageContentType;
+exports.isImageContent = isImageContent;
+const originReader = t.exact(t.type({
+    id: t.string,
+    url: t.string,
+    width: t.number,
+    height: t.number,
+}));
+exports.ImageContentView = t.exact(t.intersection([
+    t.type({
+        origin: originReader,
+        width: t.number,
+        height: t.number,
+        edit: t.type({
+            zoom: t.number,
+            crop: t.type({
+                x: t.number,
+                y: t.number,
+            }),
+            background: t.string,
+        }),
+    }),
+    t.partial({
+        url: t.string,
+        credits: validators_1.NonEmptyStringOrNull,
+        alt: validators_1.NonEmptyStringOrNull,
+        provider: validators_1.StringOrNull,
+    }),
+]));
+const legacyReader = t.intersection([
+    exports.ImageContentView,
+    t.partial({
+        thumbnails: t.record(t.string, exports.ImageContentView),
+    }),
+]);
+const ImageLegacy = (ctx) => new t.Type("ImageLegacy", exports.isImageContent, (u) => {
+    return (0, function_1.pipe)(legacyReader.decode(u), fp_ts_1.either.map((i) => exports.ImageContent.encode({ ...i, __TYPE__: exports.ImageContentType })));
+}, (i) => {
+    return {
+        content: (0, Objects_1.withOptionals)({
+            edit: i.edit,
+            height: i.height,
+            origin: i.origin,
+            width: i.width,
+        }, [
+            ["alt", i.alt],
+            ["credits", i.credits],
+            ["provider", i.provider],
+            ["thumbnails", i.thumbnails],
+            ["url", i.url],
+        ]),
+        types: { [ctx.keyOfType]: "Image" },
+    };
+});
+exports.ImageLegacy = ImageLegacy;
 exports.ImageContent = t.intersection([
-    ImageContent_1.ImageContent,
+    legacyReader,
     t.strict({
-        __TYPE__: t.literal(ImageContent_1.ImageContentType),
+        __TYPE__: t.literal(exports.ImageContentType),
     }),
 ]);
-exports.ImageContentType = ImageContent_1.ImageContentType;
-exports.ImageContentView = ImageContent_1.ImageContentView;

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

@@ -1,7 +1,16 @@
 import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const IntegrationFieldContentType = "IntegrationFieldsContent";
+export declare const isIntegrationFieldContent: (u: unknown) => u is {
+    __TYPE__: "IntegrationFieldsContent";
+    value: string;
+};
+export declare const IntegrationFieldLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    __TYPE__: "IntegrationFieldsContent";
+    value: string;
+}, WithTypes<string>, unknown>;
 export declare const IntegrationFieldContent: t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"IntegrationFieldsContent">;
     value: t.StringC;
 }>>;
 export declare type IntegrationFieldContent = t.TypeOf<typeof IntegrationFieldContent>;
-export declare const IntegrationFieldsContentType = "IntegrationFieldsContent";

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

@@ -1,11 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegrationFieldsContentType = exports.IntegrationFieldContent = void 0;
+exports.IntegrationFieldContent = exports.IntegrationFieldLegacy = exports.isIntegrationFieldContent = exports.IntegrationFieldContentType = 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 IntegrationFieldsContent_1 = require("../../../documents/widgets/nestable/IntegrationFieldsContent");
+const utils_1 = require("../../utils");
+exports.IntegrationFieldContentType = "IntegrationFieldsContent";
+const isIntegrationFieldContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.IntegrationFieldContentType;
+exports.isIntegrationFieldContent = isIntegrationFieldContent;
+const IntegrationFieldLegacy = (ctx) => new t.Type("IntegrationFieldLegacy", exports.isIntegrationFieldContent, (u) => {
+    return (0, function_1.pipe)(t.string.decode(u), fp_ts_1.either.map((i) => exports.IntegrationFieldContent.encode({
+        value: i,
+        __TYPE__: exports.IntegrationFieldContentType,
+    })));
+}, (i) => {
+    return {
+        content: i.value,
+        types: { [ctx.keyOfType]: "IntegrationFields" },
+    };
+});
+exports.IntegrationFieldLegacy = IntegrationFieldLegacy;
 exports.IntegrationFieldContent = t.strict({
-    __TYPE__: t.literal(IntegrationFieldsContent_1.IntegrationFieldsContentType),
+    __TYPE__: t.literal(exports.IntegrationFieldContentType),
     value: t.string,
 });
-exports.IntegrationFieldsContentType = IntegrationFieldsContent_1.IntegrationFieldsContentType;