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

package/src/import/validators/fields/nestable/ImportRichText/blocks/ImportBlockType.ts

@@ -0,0 +1,44 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../../validators/function"
+import { ImportEmbedBlockType } from "./ImportEmbedBlock"
+import { ImportImageBlockType } from "./ImportImageBlock"
+import { ImportTextBlockType } from "./ImportTextBlock"
+
+export type ImportBlockType =
+	| ImportTextBlockType
+	| ImportImageBlockType
+	| ImportEmbedBlockType
+
+const ImportBlockTypeValidator = withCustomError(
+	t.union([ImportTextBlockType, ImportImageBlockType, ImportEmbedBlockType]),
+	() =>
+		`Invalid block type. Supported block types are: ${Object.keys(
+			ImportTextBlockType.keys,
+		).join(", ")}, ${ImportImageBlockType.value}, ${
+			ImportEmbedBlockType.value
+		}`,
+)
+
+export const ImportBlockType = (allowedBlockTypes: string[]) =>
+	new t.Type<ImportBlockType>(
+		"ImportBlockType",
+		(u): u is ImportBlockType => ImportBlockTypeValidator.is(u),
+		(u, c) => {
+			return pipe(
+				ImportBlockTypeValidator.validate(u, c),
+				E.chain((validBlockType) =>
+					allowedBlockTypes.includes(validBlockType)
+						? t.success(validBlockType)
+						: t.failure(
+								u,
+								c,
+								`The block type '${validBlockType}' is not allowed in your document type. Enable the type for this rich text field to create the document.`,
+						  ),
+				),
+			)
+		},
+		t.identity,
+	)

package/src/import/validators/fields/nestable/ImportRichText/blocks/ImportEmbedBlock.ts

@@ -0,0 +1,13 @@
+import * as t from "io-ts"
+
+import { ImportEmbedValue } from "../../Embed"
+
+export const ImportEmbedBlockType = t.literal("embed")
+export type ImportEmbedBlockType = t.TypeOf<typeof ImportEmbedBlockType>
+
+export const ImportEmbedBlock = t.strict({
+	type: ImportEmbedBlockType,
+	oembed: ImportEmbedValue,
+})
+
+export type ImportEmbedBlock = t.TypeOf<typeof ImportEmbedBlock>

package/src/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.ts

@@ -0,0 +1,13 @@
+import * as t from "io-ts"
+
+import { String } from "../../../../../../validators"
+
+export const ImportImageBlockType = t.literal("image")
+export type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>
+
+export const ImportImageBlock = t.strict({
+	type: ImportImageBlockType,
+	id: String,
+})
+
+export type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>

package/src/import/validators/fields/nestable/ImportRichText/blocks/ImportTextBlock.ts

@@ -0,0 +1,56 @@
+import * as t from "io-ts"
+
+import { String } from "../../../../../../validators"
+import { withCustomError } from "../../../../../../validators/function"
+import { Span } from "./Span"
+
+export const ImportTextBlockTypes = {
+	Paragraph: "paragraph",
+	OListItem: "o-list-item",
+	ListItem: "list-item",
+	Heading1: "heading1",
+	Heading2: "heading2",
+	Heading3: "heading3",
+	Heading4: "heading4",
+	Heading5: "heading5",
+	Heading6: "heading6",
+	Preformatted: "preformatted",
+} as const
+
+export const ImportTextBlockType = t.keyof({
+	[ImportTextBlockTypes.Paragraph]: null,
+	[ImportTextBlockTypes.OListItem]: null,
+	[ImportTextBlockTypes.ListItem]: null,
+	[ImportTextBlockTypes.Heading1]: null,
+	[ImportTextBlockTypes.Heading2]: null,
+	[ImportTextBlockTypes.Heading3]: null,
+	[ImportTextBlockTypes.Heading4]: null,
+	[ImportTextBlockTypes.Heading5]: null,
+	[ImportTextBlockTypes.Heading6]: null,
+	[ImportTextBlockTypes.Preformatted]: null,
+})
+
+export type ImportTextBlockType = t.TypeOf<typeof ImportTextBlockType>
+
+const TextDirection = withCustomError(
+	t.union([t.literal("ltr"), t.literal("rtl")]),
+	() => "The 'direction' property must be one of the following: ltr, rtl",
+)
+
+export const ImportTextBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: ImportTextBlockType,
+			text: String,
+		}),
+		t.partial({
+			spans: withCustomError(
+				t.array(Span),
+				() => "The 'spans' field must be an array",
+			),
+			direction: TextDirection,
+		}),
+	]),
+)
+
+export type ImportTextBlock = t.TypeOf<typeof ImportTextBlock>

package/src/import/validators/fields/nestable/ImportRichText/blocks/Span.ts

@@ -0,0 +1,44 @@
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../../validators/function"
+import {
+	HyperlinkSpan,
+	HyperlinkSpanType,
+	TextSpan,
+	TextSpanType,
+} from "./spans"
+
+const SpanType = withCustomError(
+	t.union([HyperlinkSpanType, TextSpanType]),
+	() =>
+		`Span 'type' field must be specified and have one of the following values: ${Object.keys(
+			TextSpanType.keys,
+		).join(", ")} or ${HyperlinkSpanType.value}`,
+)
+export type SpanType = t.TypeOf<typeof SpanType>
+
+const SpanTypeValidator = withCustomError(
+	t.type({
+		type: SpanType,
+	}),
+	() => "Span must be an object",
+)
+
+const SpanShape = t.union([HyperlinkSpan, TextSpan])
+
+export type Span = t.TypeOf<typeof SpanShape>
+
+export const Span = SpanTypeValidator.pipe(
+	new t.Type<Span, Span, { type: SpanType }>(
+		"Span",
+		(u): u is Span => SpanShape.is(u),
+		(u, c) => {
+			if (HyperlinkSpanType.is(u.type)) {
+				return HyperlinkSpan.validate(u, c)
+			} else {
+				return TextSpan.validate(u, c)
+			}
+		},
+		t.identity,
+	),
+)

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

@@ -0,0 +1,4 @@
+export * from "./ImportBlockType"
+export * from "./ImportEmbedBlock"
+export * from "./ImportImageBlock"
+export * from "./ImportTextBlock"

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/HyperlinkSpan.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../../../validators/function"
+import { Link } from "../../../Link"
+import { SpanLocation } from "./SpanLocation"
+
+export const HyperlinkSpanType = t.literal("hyperlink")
+
+export type HyperlinkSpanType = t.TypeOf<typeof HyperlinkSpanType>
+
+export const HyperlinkSpan = t.exact(
+	t.intersection([
+		t.type({
+			type: HyperlinkSpanType,
+		}),
+		SpanLocation,
+		withCustomError(
+			t.type({
+				data: Link,
+			}),
+			() => "Hyperlink span must contain a 'data' field with link data",
+		),
+	]),
+)

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/SpanLocation.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts"
+
+import { Number } from "../../../../../../../validators"
+
+export const SpanLocation = t.type({
+	start: Number,
+	end: Number,
+})

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/TextSpan.ts

@@ -0,0 +1,26 @@
+import * as t from "io-ts"
+
+import { SpanLocation } from "./SpanLocation"
+
+const TextSpanTypes = {
+	Strong: "strong",
+	Em: "em",
+	Label: "label",
+} as const
+
+export const TextSpanType = t.keyof({
+	[TextSpanTypes.Strong]: null,
+	[TextSpanTypes.Em]: null,
+	[TextSpanTypes.Label]: null,
+})
+
+export const TextSpan = t.exact(
+	t.intersection([
+		t.type({
+			type: TextSpanType,
+		}),
+		SpanLocation,
+	]),
+)
+
+export type TextSpan = t.TypeOf<typeof TextSpan>

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/index.ts

@@ -0,0 +1,2 @@
+export * from "./HyperlinkSpan"
+export * from "./TextSpan"

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

@@ -0,0 +1,2 @@
+export { ImportBlock } from "./ImportBlock"
+export { ImportRichText } from "./ImportRichText"

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

@@ -0,0 +1,59 @@
+import type { OutputOf, TypeOf } from "io-ts"
+import * as t from "io-ts"
+
+import { DocumentId } from "../../../../utils/DocumentId"
+import { DefaultOrElse, String } from "../../../../validators"
+import { withCustomError } from "../../../../validators/function"
+import { ImportContent } from "../ImportContent"
+
+const LinkTypeValidator = t.type({
+	link_type: withCustomError(
+		t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]),
+		() => "The value must be `Web`, `Document` or `Media`",
+	),
+})
+
+const WebLink = t.exact(
+	t.intersection([
+		t.type({
+			link_type: t.literal("Web"),
+			url: String,
+		}),
+		t.partial({
+			target: String,
+		}),
+	]),
+)
+export type WebLink = t.TypeOf<typeof WebLink>
+
+const DocumentLink = t.strict({
+	link_type: t.literal("Document"),
+	id: DocumentId,
+})
+export type DocumentLink = t.TypeOf<typeof DocumentLink>
+
+const MediaLink = t.strict({
+	link_type: t.literal("Media"),
+	id: String,
+})
+export type MediaLink = t.TypeOf<typeof MediaLink>
+
+export const Link = LinkTypeValidator.pipe(
+	t.union([WebLink, DocumentLink, MediaLink]),
+)
+export type Link = TypeOf<typeof Link>
+
+// This is the default value for the link
+const AnyLink = t.strict({
+	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,12 @@
 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 { ImportRichText } from "./ImportRichText"
+import { ImportLink } from "./Link"
 import { ImportNumber } from "./Number"
 import { ImportSelect } from "./Select"
 import { ImportText } from "./Text"
@@ -18,7 +21,10 @@ export type ImportNestable =
 	| ImportDate
 	| ImportTimestamp
 	| ImportEmbed
+	| ImportLink
+	| ImportGeoPoint
 	| ImportImage
+	| ImportRichText
 
 export const ImportNestable = {
 	is(u: unknown): u is ImportNestable {
@@ -31,7 +37,10 @@ export const ImportNestable = {
 			ImportDate.is(u) ||
 			ImportTimestamp.is(u) ||
 			ImportEmbed.is(u) ||
-			ImportImage.is(u)
+			ImportLink.is(u) ||
+			ImportGeoPoint.is(u) ||
+			ImportImage().is(u) ||
+			ImportRichText().is(u)
 		)
 	},
 	decode: (field: NestableWidget) => {
@@ -52,10 +61,16 @@ 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(field)
+					case "GeoPoint":
+						return ImportGeoPoint
+					case "StructuredText":
+						return ImportRichText(field)
 					default:
 						throw new Error(`Unsupported type of nestable field ${field.type}`)
 				}

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

@@ -1,8 +1,12 @@
 export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
-export * from "./Embed"
+export { ImportEmbed } from "./Embed"
+export * from "./GeoPoint"
 export * from "./Image"
+export * from "./Image/index"
+export * from "./ImportRichText"
+export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"
 export * from "./Select"

package/src/utils/DocumentId.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts"
+
+import { refineType, withCustomError } from "../validators/function"
+
+export const DocumentId = withCustomError(
+	refineType(t.string, "DocumentId", (s) => s.length === 16),
+	() => "DocumentId must be a 16 character string",
+)

package/src/utils/Objects.ts

@@ -44,10 +44,10 @@ export function isObject(value: unknown): value is Record<string, unknown> {
 
 export function mapValues<T, O>(
 	record: Record<string, T>,
-	fn: (value: T) => O,
+	fn: (value: T, key: string) => O,
 ): Record<string, O> {
 	return Object.entries<T>(record).reduce<Record<string, O>>(
-		(acc, [key, value]) => ({ ...acc, [key]: fn(value) }),
+		(acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }),
 		{},
 	)
 }

package/src/utils/io-ts.ts

@@ -0,0 +1,29 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as RA from "fp-ts/ReadonlyArray"
+import type { Semigroup } from "fp-ts/Semigroup"
+import type { Errors, Validation } from "io-ts"
+
+/*
+ * Semigroup simply defines how to concatenate two values of the same type.
+ * In this instance, Errors from io-ts are arrays already, so we just need to concatenate them.
+ */
+const validationErrorsSemigroup: Semigroup<Errors> = {
+	concat: (a: Errors, b: Errors) => [...a, ...b],
+}
+
+/*
+ * This is a helper function to combine multiple io-ts validations into one.
+ *  t.array(...) works in the same way - it collects all the errors when decoding an array of values.
+ * 	However, it requires you to pass in a single io-ts validator as a parameter, which is not always convenient.
+ * 	Sometimes we have arrays of validation results received from function calls that don't have a validator instance.
+ */
+export const combineValidationResults = <T>(
+	validationResults: readonly Validation<T>[],
+): Validation<readonly T[]> =>
+	pipe(
+		validationResults,
+		RA.traverse(E.getApplicativeValidation(validationErrorsSemigroup))(
+			(validation) => validation,
+		),
+	)

package/src/validators/BasicTypes.ts

@@ -1,19 +1,26 @@
 import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
-import { withMessage } from "io-ts-types"
 
-export const String = withMessage(t.string, () => "The value must be a string")
-export const StringOrNull = withMessage(
+import { withCustomError } from "./function"
+
+export const String = withCustomError(
+	t.string,
+	() => "The value must be a string",
+)
+export const StringOrNull = withCustomError(
 	t.union([t.string, t.null]),
 	() => "The value must be a string or null",
 )
-export const Number = withMessage(t.number, () => "The value must be a number")
-export const NumberOrNull = withMessage(
+export const Number = withCustomError(
+	t.number,
+	() => "The value must be a number",
+)
+export const NumberOrNull = withCustomError(
 	t.union([t.number, t.null]),
 	() => "The value must be a number or null",
 )
-export const Boolean = withMessage(
+export const Boolean = withCustomError(
 	t.boolean,
 	() => "The value must be a boolean",
 )
@@ -46,8 +53,3 @@ export const EmptyArray = new t.Type<never[], never[], unknown>(
 	},
 	() => [],
 )
-
-export const AnyObject = withMessage(
-	t.record(t.string, t.unknown),
-	() => "The value must be an object",
-)

package/src/validators/DefaultOrElse.ts

@@ -6,7 +6,7 @@ import { EmptyArray, EmptyObject } from "./BasicTypes"
 export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
 	return (codec: t.Type<A, O>) =>
 		new t.Type<A | null, O | undefined>(
-			"NullOrT",
+			"DefaultOrElse",
 			(u: unknown): u is A | null => null === u || codec.is(u),
 			(u: unknown) => {
 				if (isRight(inputValidator.decode(u))) return t.success(null)

package/src/validators/NonEmptyString.ts

@@ -1,9 +1,8 @@
 import * as t from "io-ts"
 
-import { refineType } from "./function"
+import { refineType, withCustomError } from "./function"
 
-export default refineType(
-	t.string,
-	"nonEmptyString",
-	(s) => s.trim().length > 0,
+export default withCustomError(
+	refineType(t.string, "nonEmptyString", (s) => s.trim().length > 0),
+	() => "The value must be a non-empty 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(
+ * 		withCustomError(
+ * 			t.type({age: withCustomError(t.number, () => 'Invalid child')}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid child"}])
+ * expect(
+ * 		withCustomError(
+ * 			t.type({age: t.number}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid parent"}])
+ */
+export function withCustomError<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"

package/lib/import/validators/fields/nestable/Image.d.ts

@@ -1,24 +0,0 @@
-import * as t from "io-ts";
-export declare type ImageField = {
-    id: string;
-    edit?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        zoom: number;
-        background: string;
-    };
-    alt?: string | null;
-    credit?: string | null;
-};
-declare type ImageFieldWithThumbnails = ImageField & {
-    thumbnails: Record<string, ImageField>;
-};
-declare const ImageFieldWithThumbnails: t.Type<ImageFieldWithThumbnails, ImageFieldWithThumbnails, unknown>;
-export declare const ImportImage: t.Type<{
-    type: "Image";
-    value: ImageFieldWithThumbnails | null;
-}, ImageFieldWithThumbnails | undefined, unknown>;
-export declare type ImportImage = t.TypeOf<typeof ImportImage>;
-export {};