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

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampContent = exports.TimestampLegacy = exports.isTimestampContent = 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 isTimestampContent = (u) => (0, utils_1.hasContentType)(u) &&
+    u.__TYPE__ === common_1.FieldContentType &&
+    (0, utils_1.hasFieldContentType)(u) &&
+    u.type === "Timestamp";
+exports.isTimestampContent = isTimestampContent;
+const TimestampLegacy = (ctx) => new t.Type("TimestampLegacy", exports.isTimestampContent, (u) => {
+    return (0, function_1.pipe)(TrimmedString_1.default.decode(u), fp_ts_1.either.map((f) => exports.TimestampContent.encode({
+        value: f,
+        type: widgets_1.TimestampFieldType,
+        __TYPE__: common_1.FieldContentType,
+    })));
+}, (b) => {
+    return {
+        content: b.value,
+        types: { [ctx.keyOfType]: widgets_1.TimestampFieldType },
+        keys: {},
+    };
+});
+exports.TimestampLegacy = TimestampLegacy;
+exports.TimestampContent = t.strict({
+    type: t.literal(widgets_1.TimestampFieldType),
+    value: TrimmedString_1.default,
+    __TYPE__: t.literal(common_1.FieldContentType),
+});

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

@@ -0,0 +1 @@
+export declare const FieldContentType = "FieldContent";

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContentType = void 0;
+exports.FieldContentType = "FieldContent";

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/GeoPointContent.d.ts

@@ -0,0 +1,33 @@
+import * as t from "io-ts";
+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";
+}, 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>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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" },
+    keys: {},
+}));
+exports.GeoPointLegacy = GeoPointLegacy;
+exports.GeoPointContent = t.intersection([
+    legacyReader,
+    t.strict({
+        __TYPE__: t.literal(exports.GeoPointContentType),
+    }),
+]);

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

@@ -0,0 +1,252 @@
+import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+export declare const ImageContentType = "ImageContent";
+export declare const isImageContent: (u: unknown) => u is {
+    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;
+        };
+    };
+} & {
+    __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;
+        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;
+        };
+    };
+} & {
+    __TYPE__: "ImageContent";
+}, 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;
+        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.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>;
+interface BuildCropUrlArgs {
+    origin: ImageContent["origin"];
+    /** Image crop parameters */
+    croppedImage: CroppedImage;
+}
+export declare function buildCropUrl(args: BuildCropUrlArgs): string;
+export interface CroppedImage {
+    zoom: number;
+    /** X coordinate of the crop rect on the original image */
+    x: number;
+    /** Y coordinate of the crop rect on the original image */
+    y: number;
+    /** The width of the crop rect over the original image */
+    cropWidth: number;
+    /** The height of the crop rect over the original image */
+    cropHeight: number;
+    /** Final (user defined via W input) height of the image */
+    width: number;
+    /** Final (user defined via H input) height of the image */
+    height: number;
+}
+export declare function getCroppedImage({ contentView, }: {
+    contentView: ImageContentView;
+}): CroppedImage;
+export {};

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCroppedImage = exports.buildCropUrl = 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 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" },
+        keys: {},
+    };
+});
+exports.ImageLegacy = ImageLegacy;
+exports.ImageContent = t.intersection([
+    legacyReader,
+    t.strict({
+        __TYPE__: t.literal(exports.ImageContentType),
+    }),
+]);
+function buildCropUrl(args) {
+    const { origin, croppedImage } = args;
+    const { x, y, width, height, cropHeight, cropWidth } = croppedImage;
+    const url = new URL(origin.url);
+    const hasResize = origin.height !== height || origin.width !== width;
+    const hasCrop = x !== 0 ||
+        y !== 0 ||
+        cropHeight !== origin.height ||
+        cropWidth !== origin.width;
+    if (hasCrop) {
+        const crop = [x, y, cropWidth, cropHeight].map(Math.round).join(",");
+        url.searchParams.set("rect", crop);
+        url.searchParams.set("w", width.toString());
+        url.searchParams.set("h", height.toString());
+    }
+    if (hasResize) {
+        url.searchParams.set("w", width.toString());
+        url.searchParams.set("h", height.toString());
+    }
+    return url.toString();
+}
+exports.buildCropUrl = buildCropUrl;
+function getCroppedImage({ contentView, }) {
+    const { edit: { crop: { x, y }, zoom, }, width, height, origin: { width: originWidth, height: originHeight }, } = contentView;
+    let cropWidth;
+    let cropHeight;
+    const originAspect = originWidth / originHeight;
+    const cropAspect = width / height;
+    if (cropAspect >= originAspect) {
+        // crop and origin image would be the same width if zoom was equal to 1
+        cropWidth = originWidth / zoom;
+        cropHeight = cropWidth / cropAspect;
+    }
+    else {
+        // crop and origin image would be the same height if zoom was equal to 1
+        cropHeight = originHeight / zoom;
+        cropWidth = cropHeight * cropAspect;
+    }
+    return {
+        x,
+        y,
+        width,
+        height,
+        zoom,
+        cropWidth,
+        cropHeight,
+    };
+}
+exports.getCroppedImage = getCroppedImage;

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

@@ -0,0 +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>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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" },
+        keys: {},
+    };
+});
+exports.IntegrationFieldLegacy = IntegrationFieldLegacy;
+exports.IntegrationFieldContent = t.strict({
+    __TYPE__: t.literal(exports.IntegrationFieldContentType),
+    value: t.string,
+});