@prismicio/types-internal 2.2.0-alpha.2 → 2.2.0-alpha.4

package/lib/validators/function.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addType = exports.isEmpty = exports.objectToMap = exports.grouped = exports.formatDate = exports.formatDateTime = exports.filterDouble = exports.refineType = exports.nullable = void 0;
+exports.withFallbackMessage = exports.addType = exports.isEmpty = exports.objectToMap = exports.grouped = exports.formatDate = exports.formatDateTime = exports.filterDouble = exports.refineType = exports.nullable = 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 io_ts_types_1 = require("io-ts-types");
 const mapOutput_1 = require("io-ts-types/mapOutput");
 function nullable(c) {
     return t.union([c, t.null, t.undefined]);
@@ -58,3 +59,42 @@ function addType(codec, t) {
     return (0, mapOutput_1.mapOutput)(codec, (o) => ({ ...o, __TYPE__: t }));
 }
 exports.addType = addType;
+/**
+ * Returns a clone of the given codec that tries to find sub-error with message already set.
+ * If there is such error it just returns sub-errors array.
+ * If there is no such error it generates new error with given message.
+ *
+ * @example
+ * expect(
+ * 		withFallbackMessage(
+ * 			t.type({age: withMessage(t.number, () => 'Invalid child')}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid child"}])
+ * expect(
+ * 		withFallbackMessage(
+ * 			t.type({age: t.number}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid parent"}])
+ */
+function withFallbackMessage(codec, message) {
+    return (0, io_ts_types_1.withValidate)(codec, (i, c) => {
+        return fp_ts_1.either.mapLeft((errors) => {
+            if (errors.find((error) => error.message)) {
+                return errors;
+            }
+            return [
+                {
+                    value: i,
+                    context: c,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    message: message(i, c),
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    actual: i,
+                },
+            ];
+        })(codec.validate(i, c));
+    });
+}
+exports.withFallbackMessage = withFallbackMessage;

package/lib/validators/index.d.ts

@@ -9,6 +9,7 @@ export { default as IntFromPixels } from "./IntFromPixels";
 export { default as NonEmptyString } from "./NonEmptyString";
 export { default as NonEmptyStringOrNull } from "./NonEmptyStringOrNull";
 export { default as NumberOrNull } from "./NumberOrNull";
+export { default as NumberRange } from "./NumberRange";
 export { default as StringFromBoolean } from "./StringFromBoolean";
 export { default as StringFromNumber } from "./StringFromNumber";
 export { default as StringOrNull } from "./StringOrNull";

package/lib/validators/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringOrNull = exports.StringFromNumber = exports.StringFromBoolean = exports.NumberOrNull = exports.NonEmptyStringOrNull = exports.NonEmptyString = exports.IntFromPixels = exports.IntFromNumber = exports.Function = exports.DateFromTsMs = exports.DateFromStringOrNumber = exports.DateFromString = void 0;
+exports.StringOrNull = exports.StringFromNumber = exports.StringFromBoolean = exports.NumberRange = exports.NumberOrNull = exports.NonEmptyStringOrNull = exports.NonEmptyString = exports.IntFromPixels = exports.IntFromNumber = exports.Function = exports.DateFromTsMs = exports.DateFromStringOrNumber = exports.DateFromString = void 0;
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./BasicTypes"), exports);
 var DateFromString_1 = require("./DateFromString");
@@ -21,6 +21,8 @@ var NonEmptyStringOrNull_1 = require("./NonEmptyStringOrNull");
 Object.defineProperty(exports, "NonEmptyStringOrNull", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NonEmptyStringOrNull_1).default; } });
 var NumberOrNull_1 = require("./NumberOrNull");
 Object.defineProperty(exports, "NumberOrNull", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NumberOrNull_1).default; } });
+var NumberRange_1 = require("./NumberRange");
+Object.defineProperty(exports, "NumberRange", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NumberRange_1).default; } });
 var StringFromBoolean_1 = require("./StringFromBoolean");
 Object.defineProperty(exports, "StringFromBoolean", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(StringFromBoolean_1).default; } });
 var StringFromNumber_1 = require("./StringFromNumber");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.2",
+	"version": "2.2.0-alpha.4",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/common/Asset.ts

@@ -0,0 +1,15 @@
+export type Asset = {
+	id: string
+	last_modified: string
+	kind: "image" | "all"
+	filename?: string
+	extension?: string
+	size?: string
+	origin_url: string
+	url: string
+	width?: number
+	height?: number
+	notes?: string
+	credits?: string
+	alt?: string
+}

package/src/common/index.ts

@@ -1 +1,2 @@
+export * from "./Asset"
 export * from "./WidgetKey"

package/src/import/converters/Document.ts

@@ -1,15 +1,16 @@
+import type { Asset } from "../../common"
 import type { Document, WidgetContent } from "../../content"
 import type { ImportDocument } from "../validators"
 import type { ImportField } from "../validators/fields/ImportField"
-import { Asset, convertNestableWidget, uidConverter } from "./fields"
+import { convertNestableWidget, uidConverter } from "./fields"
 
 export function convertImportToContent(
 	document: ImportDocument,
-	images: Map<string, Asset>,
+	assets: Record<string, Asset>,
 ): Document {
 	return Object.entries(document).reduce<Document>(
 		(acc, [fieldKey, fieldValue]) => {
-			const newFieldValue = convertWidget(fieldValue, images)
+			const newFieldValue = convertWidget(fieldValue, assets)
 			return newFieldValue ? { ...acc, [fieldKey]: newFieldValue } : acc
 		},
 		{},
@@ -18,12 +19,12 @@ export function convertImportToContent(
 
 function convertWidget(
 	field: ImportField,
-	images: Map<string, Asset>,
+	assets: Record<string, Asset>,
 ): WidgetContent | undefined {
 	switch (field.type) {
 		case "UID":
 			return uidConverter(field.value)
 		default:
-			return convertNestableWidget(field, images)
+			return convertNestableWidget(field, assets)
 	}
 }

package/src/import/converters/fields/nestable/GeooPoint.ts

@@ -0,0 +1,16 @@
+import type { GeoPointContent } from "../../../../content"
+import type { ImportGeoPoint } from "../../../validators"
+
+export const geopointConverter = (
+	field: ImportGeoPoint["value"],
+): GeoPointContent | undefined => {
+	if (field === null) return
+
+	return {
+		position: {
+			lat: field.latitude,
+			lng: field.longitude,
+		},
+		__TYPE__: "GeoPointContent",
+	}
+}

package/src/import/converters/fields/nestable/Image.ts

@@ -1,34 +1,19 @@
+import type { Asset } from "../../../../common"
 import type { ImageContent } from "../../../../content"
 import { mapValues, withOptionals } from "../../../../utils/Objects"
 import type { ImageField, ImportImage } from "../../../validators"
 
-export type Asset = {
-	id: string
-	last_modified: string
-	kind: "image" | "all"
-	filename?: string
-	extension?: string
-	size?: string
-	origin_url: string
-	url: string
-	width?: number
-	height?: number
-	notes?: string
-	credits?: string
-	alt?: string
-}
-
 function convertImage(field: ImageField, image: Asset) {
 	return withOptionals<Omit<ImageContent, "__TYPE__" | "thumbnails">>(
 		{
 			origin: {
 				id: field.id,
 				url: image.origin_url,
-				width: image.width!,
-				height: image.height!,
+				width: image.width ?? 0,
+				height: image.height ?? 0,
 			},
-			width: field.edit?.width ?? image.width!,
-			height: field.edit?.height ?? image.height!,
+			width: field.edit?.width ?? image.width ?? 0,
+			height: field.edit?.height ?? image.height ?? 0,
 			edit: {
 				zoom: field.edit?.zoom ?? 1,
 				crop: {
@@ -48,10 +33,10 @@ function convertImage(field: ImageField, image: Asset) {
 
 export const imageConverter = (
 	field: ImportImage["value"],
-	images: Map<string, Asset>,
+	assets: Record<string, Asset>,
 ): ImageContent | undefined => {
 	const getImageById = (id: string): Asset => {
-		const image = images.get(id)
+		const image = assets[id]
 		if (!image) throw new Error(`Missing asset with id '${id}'`)
 		return image
 	}

package/src/import/converters/fields/nestable/Link.ts

@@ -0,0 +1,33 @@
+import type { LinkContent } from "../../../../content"
+import type { ImportLink } from "../../../validators"
+
+export const linkConverter = (
+	field: ImportLink["value"],
+): LinkContent | undefined => {
+	if (field === null) {
+		return
+	}
+
+	switch (field.link_type) {
+		case "Web":
+			return {
+				value: {
+					url: field.url,
+					target: field.target,
+					__TYPE__: "ExternalLink",
+				},
+				__TYPE__: "LinkContent",
+			}
+		case "Document":
+			return {
+				value: {
+					id: field.id,
+					__TYPE__: "DocumentLink",
+				},
+				__TYPE__: "LinkContent",
+			}
+		// TODO: https://linear.app/prismic/issue/AGE-90/[content-validation-and-error-management]-link-to-media
+		case "Media":
+			return undefined
+	}
+}

package/src/import/converters/fields/nestable/Nestable.ts

@@ -1,12 +1,14 @@
+import type { Asset } from "../../../../common"
 import type { WidgetContent } from "../../../../content"
 import type { ImportNestable } from "../../../validators"
 import {
-	Asset,
 	booleanConverter,
 	colorConverter,
 	dateConverter,
 	embedConverter,
+	geopointConverter,
 	imageConverter,
+	linkConverter,
 	numberConverter,
 	selectConverter,
 	textConverter,
@@ -15,7 +17,7 @@ import {
 
 export function convertNestableWidget(
 	field: ImportNestable,
-	images: Map<string, Asset>,
+	assets: Record<string, Asset>,
 ): WidgetContent | undefined {
 	switch (field.type) {
 		case "Boolean":
@@ -34,8 +36,12 @@ export function convertNestableWidget(
 			return timestampConverter(field.value)
 		case "Embed":
 			return embedConverter(field.value)
+		case "GeoPoint":
+			return geopointConverter(field.value)
+		case "Link":
+			return linkConverter(field.value)
 		case "Image":
-			return imageConverter(field.value, images)
+			return imageConverter(field.value, assets)
 		default:
 			throw new Error(
 				`Unsupported type of nestable converter ${JSON.stringify(field)}`,

package/src/import/converters/fields/nestable/index.ts

@@ -2,7 +2,9 @@ export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
 export * from "./Embed"
+export * from "./GeooPoint"
 export * from "./Image"
+export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"
 export * from "./Select"

package/src/import/validators/fields/nestable/GeoPoint.ts

@@ -0,0 +1,21 @@
+import type { TypeOf } from "io-ts"
+import * as t from "io-ts"
+
+import { EmptyObjectOrElse, NumberRange } from "../../../../validators"
+import { withFallbackMessage } from "../../../../validators/function"
+import { ImportContent } from "../ImportContent"
+
+const GeooPoint = withFallbackMessage(
+	t.strict({
+		latitude: NumberRange(-90, 90, "latitude"),
+		longitude: NumberRange(-180, 180, "longitude"),
+	}),
+	() =>
+		"GeoPoint must be an object with the properties `latitude` and `longitude` between the given ranges",
+)
+
+export const ImportGeoPoint = ImportContent(
+	"GeoPoint",
+	EmptyObjectOrElse(GeooPoint),
+)
+export type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>

package/src/import/validators/fields/nestable/Image.ts

@@ -31,24 +31,11 @@ const ImageFieldCodec = AnyObject.pipe(
 )
 
 const ThumbnailsCodec = t.record(t.string, ImageFieldCodec)
+type Thumbnails = t.TypeOf<typeof ThumbnailsCodec>
 
-export type ImageField = {
-	id: string
-	edit?: {
-		x: number
-		y: number
-		width: number
-		height: number
-		zoom: number
-		background: string
-	}
-	alt?: string | null
-	credit?: string | null
-}
+export type ImageField = t.TypeOf<typeof ImageFieldCodec>
 
-type ImageFieldWithThumbnails = ImageField & {
-	thumbnails: Record<string, ImageField>
-}
+type ImageFieldWithThumbnails = ImageField & { thumbnails: Thumbnails }
 
 const ImageFieldWithThumbnails = new t.Type(
 	"ImageFieldWithThumbnails",

package/src/import/validators/fields/nestable/Link.ts

@@ -0,0 +1,51 @@
+import type { OutputOf, TypeOf } from "io-ts"
+import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
+
+import { DocumentId } from "../../../../utils/DocumentId"
+import { DefaultOrElse, String } from "../../../../validators"
+import { ImportContent } from "../ImportContent"
+
+const LinkTypeValidator = t.type({
+	link_type: withMessage(
+		t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]),
+		() => "The value must be `Web`, `Document` or `Media`",
+	),
+})
+
+const WebLink = t.intersection([
+	t.type({
+		link_type: t.literal("Web"),
+		url: String,
+	}),
+	t.partial({
+		target: String,
+	}),
+])
+
+const DocumentLink = t.type({
+	link_type: t.literal("Document"),
+	id: DocumentId,
+})
+
+const MediaLink = t.type({
+	link_type: t.literal("Media"),
+	id: String,
+})
+
+const Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]))
+
+// This is the default value for the link
+const AnyLink = t.type({
+	link_type: t.literal("Any"),
+})
+
+export const ImportLink = ImportContent(
+	"Link",
+	DefaultOrElse<
+		TypeOf<typeof AnyLink>,
+		TypeOf<typeof Link>,
+		OutputOf<typeof Link>
+	>(AnyLink)(Link),
+)
+export type ImportLink = TypeOf<typeof ImportLink>

package/src/import/validators/fields/nestable/Nestable.ts

@@ -1,9 +1,11 @@
 import type { NestableWidget } from "../../../../customtypes"
-import { ImportBoolean } from "."
+import { ImportBoolean } from "./Boolean"
 import { ImportColor } from "./Color"
 import { ImportDate } from "./Date"
 import { ImportEmbed } from "./Embed"
+import { ImportGeoPoint } from "./GeoPoint"
 import { ImportImage } from "./Image"
+import { ImportLink } from "./Link"
 import { ImportNumber } from "./Number"
 import { ImportSelect } from "./Select"
 import { ImportText } from "./Text"
@@ -18,6 +20,8 @@ export type ImportNestable =
 	| ImportDate
 	| ImportTimestamp
 	| ImportEmbed
+	| ImportLink
+	| ImportGeoPoint
 	| ImportImage
 
 export const ImportNestable = {
@@ -31,6 +35,8 @@ export const ImportNestable = {
 			ImportDate.is(u) ||
 			ImportTimestamp.is(u) ||
 			ImportEmbed.is(u) ||
+			ImportLink.is(u) ||
+			ImportGeoPoint.is(u) ||
 			ImportImage.is(u)
 		)
 	},
@@ -52,10 +58,14 @@ export const ImportNestable = {
 						return ImportDate
 					case "Timestamp":
 						return ImportTimestamp
-					case "Image":
-						return ImportImage
 					case "Embed":
 						return ImportEmbed
+					case "Link":
+						return ImportLink
+					case "Image":
+						return ImportImage
+					case "GeoPoint":
+						return ImportGeoPoint
 					default:
 						throw new Error(`Unsupported type of nestable field ${field.type}`)
 				}

package/src/import/validators/fields/nestable/index.ts

@@ -2,7 +2,9 @@ export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
 export * from "./Embed"
+export * from "./GeoPoint"
 export * from "./Image"
+export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"
 export * from "./Select"

package/src/utils/DocumentId.ts

@@ -0,0 +1,9 @@
+import { withMessage } from "io-ts-types"
+
+import { String } from "../validators"
+import { refineType } from "../validators/function"
+
+export const DocumentId = withMessage(
+	refineType(String, "DocumentId", (s) => s.length === 16),
+	() => "DocumentId must be a 16 character string",
+)

package/src/validators/NumberRange.ts

@@ -0,0 +1,51 @@
+import * as t from "io-ts"
+
+import { Number } from "./BasicTypes"
+
+/**
+ * Creates a custom runtime type for validating that a number falls within a specified range.
+ *
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @param fieldName - The name of the field being validated (used in error messages).
+ * @returns A runtime type representing the number range validation.
+ *
+ *  * @example
+ * // Creating a custom runtime type for age validation
+ * const AgeType = numberInRange(18, 99, 'Age');
+ *
+ * // Valid age
+ * const validAgeResult = AgeType.decode(25);
+ * if (t.isRight(validAgeResult)) {
+ *   console.log('Valid age:', validAgeResult.right); // Output: Valid age: 25
+ * } else {
+ *   console.error('Invalid age:', t.left(validAgeResult).map(t.reporter.report));
+ * }
+ *
+ * @example
+ * // Invalid age
+ * const invalidAgeResult = AgeType.decode(15);
+ * if (t.isRight(invalidAgeResult)) {
+ *   console.log('Valid age:', invalidAgeResult.right);
+ * } else {
+ *   console.error('Invalid age:', t.left(invalidAgeResult).map(t.reporter.report));
+ * }
+ */
+export default (min: number, max: number, fieldName: string) =>
+	Number.pipe(
+		new t.Type<number, number, number>(
+			"numberInRange",
+			(u: unknown): u is number => Number.is(u),
+			(u: number, context) => {
+				if (u > max || u < min) {
+					return t.failure(
+						u,
+						context,
+						`${fieldName} must be a number between ${min} and ${max}`,
+					)
+				}
+				return t.success(u)
+			},
+			t.identity,
+		),
+	)

package/src/validators/function.ts

@@ -1,6 +1,7 @@
 import { either } from "fp-ts"
 import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
+import { withValidate } from "io-ts-types"
 import { mapOutput } from "io-ts-types/mapOutput"
 
 export function nullable<A, O>(c: t.Type<A, O>) {
@@ -69,3 +70,46 @@ export function addType<A, O extends object, I, T extends string>(
 ): t.Type<A, O & { __TYPE__: T }, I> {
 	return mapOutput(codec, (o) => ({ ...o, __TYPE__: t } as const))
 }
+
+/**
+ * Returns a clone of the given codec that tries to find sub-error with message already set.
+ * If there is such error it just returns sub-errors array.
+ * If there is no such error it generates new error with given message.
+ *
+ * @example
+ * expect(
+ * 		withFallbackMessage(
+ * 			t.type({age: withMessage(t.number, () => 'Invalid child')}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid child"}])
+ * expect(
+ * 		withFallbackMessage(
+ * 			t.type({age: t.number}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid parent"}])
+ */
+export function withFallbackMessage<C extends t.Any>(
+	codec: C,
+	message: (i: t.InputOf<C>, c: t.Context) => string,
+): C {
+	return withValidate(codec, (i, c) => {
+		return either.mapLeft((errors: t.Errors) => {
+			if (errors.find((error) => error.message)) {
+				return errors
+			}
+
+			return [
+				{
+					value: i,
+					context: c,
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+					message: message(i, c),
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+					actual: i,
+				},
+			]
+		})(codec.validate(i, c))
+	})
+}

package/src/validators/index.ts

@@ -9,6 +9,7 @@ export { default as IntFromPixels } from "./IntFromPixels"
 export { default as NonEmptyString } from "./NonEmptyString"
 export { default as NonEmptyStringOrNull } from "./NonEmptyStringOrNull"
 export { default as NumberOrNull } from "./NumberOrNull"
+export { default as NumberRange } from "./NumberRange"
 export { default as StringFromBoolean } from "./StringFromBoolean"
 export { default as StringFromNumber } from "./StringFromNumber"
 export { default as StringOrNull } from "./StringOrNull"