@prismicio/types-internal 3.15.0 → 3.16.0

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

@@ -0,0 +1,236 @@
+import * as t from "io-ts";
+import type { ContentPath, TraverseWidgetContentFn } from "../../_internal/utils";
+import { type Link, NestableFieldTypes, NestableWidget } from "../../customtypes";
+import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
+export declare const RepeatableContentType: "RepeatableContent";
+export declare const RepeatableFieldType: "Repeatable";
+export declare const RepeatableItemContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"LinkContent">;
+    value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"ImageLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        kind: t.StringC;
+        id: t.StringC;
+        url: t.StringC;
+        height: t.StringC;
+        width: t.StringC;
+        size: t.StringC;
+        name: t.StringC;
+    }>>, t.ExactC<t.PartialC<{
+        date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>]>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"image">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"FileLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        kind: t.StringC;
+        id: t.StringC;
+        url: t.StringC;
+        name: t.StringC;
+        size: t.StringC;
+    }>, t.PartialC<{
+        date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"file">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"DocumentLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        id: t.Type<string, string, unknown>;
+    }>>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"document">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"ExternalLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        url: t.StringC;
+    }>, t.PartialC<{
+        kind: t.LiteralC<"web">;
+        target: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        preview: t.UnionC<[t.Type<{
+            title?: string;
+        }, {
+            title?: string;
+        }, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"web">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"MediaLink">;
+    }>>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"media">;
+        text: t.StringC;
+    }>>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"AnyLink">;
+    }>>, t.ExactC<t.TypeC<{
+        text: t.StringC;
+    }>>]>]>;
+}>>;
+export declare type RepeatableItemContent = t.TypeOf<typeof RepeatableItemContent>;
+export declare const RepeatableContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"RepeatableContent">;
+    type: t.UnionC<[t.LiteralC<"Color">, t.LiteralC<"Boolean">, t.LiteralC<"Embed">, t.LiteralC<"GeoPoint">, t.LiteralC<"Date">, t.LiteralC<"Number">, t.LiteralC<"Range">, t.LiteralC<"StructuredText">, t.LiteralC<"Select">, t.LiteralC<"Separator">, t.LiteralC<"Text">, t.LiteralC<"Timestamp">, t.LiteralC<"Link">, t.LiteralC<"Image">, t.LiteralC<"IntegrationFields">]>;
+    value: t.ArrayC<t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"LinkContent">;
+        value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"ImageLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            kind: t.StringC;
+            id: t.StringC;
+            url: t.StringC;
+            height: t.StringC;
+            width: t.StringC;
+            size: t.StringC;
+            name: t.StringC;
+        }>>, t.ExactC<t.PartialC<{
+            date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"image">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"FileLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            kind: t.StringC;
+            id: t.StringC;
+            url: t.StringC;
+            name: t.StringC;
+            size: t.StringC;
+        }>, t.PartialC<{
+            date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        }>]>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"file">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"DocumentLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            id: t.Type<string, string, unknown>;
+        }>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"document">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"ExternalLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            url: t.StringC;
+        }>, t.PartialC<{
+            kind: t.LiteralC<"web">;
+            target: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            preview: t.UnionC<[t.Type<{
+                title?: string;
+            }, {
+                title?: string;
+            }, unknown>, t.NullC, t.UndefinedC]>;
+        }>]>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"web">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"MediaLink">;
+        }>>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"media">;
+            text: t.StringC;
+        }>>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"AnyLink">;
+        }>>, t.ExactC<t.TypeC<{
+            text: t.StringC;
+        }>>]>]>;
+    }>>>;
+}>>;
+export declare type RepeatableContent = t.TypeOf<typeof RepeatableContent>;
+export declare const isRepeatableContent: t.Is<{
+    __TYPE__: "RepeatableContent";
+    type: "Boolean" | "Color" | "Date" | "Embed" | "GeoPoint" | "Image" | "IntegrationFields" | "Link" | "Number" | "Range" | "StructuredText" | "Select" | "Separator" | "Text" | "Timestamp";
+    value: {
+        __TYPE__: "LinkContent";
+        value: ({
+            __TYPE__: "ImageLink";
+        } & (({
+            kind: string;
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        } & {
+            text?: string;
+        }) | {
+            kind: "image";
+            text: string;
+        })) | ({
+            __TYPE__: "FileLink";
+        } & (({
+            kind: string;
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        } & {
+            text?: string;
+        }) | {
+            kind: "file";
+            text: string;
+        })) | ({
+            __TYPE__: "MediaLink";
+        } & {
+            kind: "media";
+            text: string;
+        }) | ({
+            __TYPE__: "DocumentLink";
+        } & (({
+            id: string;
+        } & {
+            text?: string;
+        }) | {
+            kind: "document";
+            text: string;
+        })) | ({
+            __TYPE__: "ExternalLink";
+        } & (({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        } & {
+            text?: string;
+        }) | {
+            kind: "web";
+            text: string;
+        })) | ({
+            __TYPE__: "AnyLink";
+        } & {
+            text: string;
+        });
+    }[];
+}>;
+export declare const RepeatableLegacy: (ctx: LegacyContentCtx, fieldType: NestableFieldTypes) => t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>;
+export declare type RepeatableCustomType = Link;
+export declare function traverseRepeatableContent({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    content: RepeatableContent;
+    model?: NestableWidget | undefined;
+}): (transform: TraverseWidgetContentFn) => RepeatableContent | undefined;

package/lib/content/fields/RepeatableContent.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseRepeatableContent = exports.RepeatableLegacy = exports.isRepeatableContent = exports.RepeatableContent = exports.RepeatableItemContent = exports.RepeatableFieldType = exports.RepeatableContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const Either_1 = require("fp-ts/lib/Either");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const customtypes_1 = require("../../customtypes");
+const nestable_1 = require("./nestable");
+exports.RepeatableContentType = "RepeatableContent";
+exports.RepeatableFieldType = "Repeatable";
+exports.RepeatableItemContent = nestable_1.LinkContent;
+exports.RepeatableContent = t.strict({
+    __TYPE__: t.literal(exports.RepeatableContentType),
+    type: customtypes_1.NestableFieldTypes,
+    // TODO: How to ensure it's an array of only one type
+    value: t.array(exports.RepeatableItemContent),
+});
+exports.isRepeatableContent = exports.RepeatableContent.is;
+const RepeatableLegacy = (ctx, fieldType) => {
+    const codecDecode = t.array(t.unknown);
+    const codecEncode = t.array(exports.RepeatableItemContent);
+    return new t.Type("RepeatableLegacy", exports.isRepeatableContent, (items) => {
+        const parsed = (0, function_1.pipe)(codecDecode.decode(items), fp_ts_1.either.map((items) => {
+            const parsedItems = items.reduce((acc, item) => {
+                let result;
+                switch (fieldType) {
+                    case "Link":
+                        result = (0, nestable_1.LinkContentLegacy)(ctx).decode(item);
+                        break;
+                }
+                if (!result)
+                    return acc;
+                if ((0, Either_1.isLeft)(result))
+                    return acc;
+                return [...acc, result.right];
+            }, []);
+            return {
+                value: parsedItems,
+                type: fieldType,
+                __TYPE__: exports.RepeatableContentType,
+            };
+        }));
+        return parsed;
+    }, (r) => {
+        const res = codecEncode.encode(r.value);
+        const encodedItems = res.reduce((acc, item) => {
+            let encoded;
+            switch (item.__TYPE__) {
+                case nestable_1.LinkContentType:
+                    encoded = (0, nestable_1.LinkContentLegacy)(ctx).encode(item);
+                    break;
+            }
+            if (!encoded)
+                return acc;
+            return [...acc, encoded];
+        }, []);
+        return {
+            content: encodedItems.map((encodedItem) => encodedItem.content),
+            types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
+        };
+    });
+};
+exports.RepeatableLegacy = RepeatableLegacy;
+function traverseRepeatableContent({ path, key, apiId, model, content, }) {
+    return (transform) => {
+        const items = content.value.reduce((acc, fieldContent, index) => {
+            const itemPath = path.concat([
+                { key: index.toString(), type: "Widget" },
+            ]);
+            const transformedField = transform({
+                path: itemPath,
+                key: key,
+                apiId: apiId,
+                model: model,
+                content: fieldContent,
+            });
+            // Can happen if the transform function returns undefined to filter out a field
+            if (!transformedField)
+                return acc;
+            return acc.concat(transformedField);
+        }, []);
+        return transform({
+            path,
+            key,
+            apiId,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                type: content.type,
+                value: items,
+            },
+        });
+    };
+}
+exports.traverseRepeatableContent = traverseRepeatableContent;

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

@@ -225,3 +225,28 @@ export declare const ImageContent: t.IntersectionC<[t.IntersectionC<[t.ExactC<t.
     __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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageContent = exports.ImageLegacy = exports.ImageContentView = exports.isImageContent = exports.ImageContentType = void 0;
+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");
@@ -71,3 +71,52 @@ exports.ImageContent = t.intersection([
         __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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.15.0",
+	"version": "3.16.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",
@@ -23,10 +23,6 @@
 		"dev": "tsc --watch",
 		"format": "prettier --write .",
 		"prepare": "npm run build",
-		"release": "npm run test && standard-version && git push --follow-tags && npm run build && npm publish",
-		"release:dry": "standard-version --dry-run",
-		"release:alpha": "npm run test && standard-version --prerelease alpha --release-as minor && git push --follow-tags && npm run build && npm publish --tag alpha",
-		"release:alpha:dry": "standard-version --prerelease alpha --release-as minor --dry-run",
 		"test": "jest --no-cache --silent=false --verbose=false --coverage",
 		"test:watch": "npm run test -- --watch",
 		"test:clear": "jest --clearCache",

package/src/content/fields/nestable/ImageContent.ts

@@ -99,3 +99,98 @@ export const ImageContent = t.intersection([
 ])
 
 export type ImageContent = t.TypeOf<typeof ImageContent>
+
+// Helpers to build image crop URLs (used in editor, migration-api, and prismic-mocks)
+interface BuildCropUrlArgs {
+	origin: ImageContent["origin"]
+	/** Image crop parameters */
+	croppedImage: CroppedImage
+}
+
+export function buildCropUrl(args: BuildCropUrlArgs) {
+	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()
+}
+
+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 function getCroppedImage({
+	contentView,
+}: {
+	contentView: ImageContentView
+}): CroppedImage {
+	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,
+	}
+}