@prismicio/types-internal 2.2.1-alpha.0 → 2.2.1-remove-import.alpha-1

package/src/import/validators/fields/RepeatableZoneItem.ts

@@ -1,64 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import { WidgetKey } from "../../../common"
-import type { NestableWidget } from "../../../customtypes"
-import { withCustomError } from "../../../validators/function"
-import { ImportNestable } from "./nestable"
-
-export type RepeatableZoneItem = Record<WidgetKey, ImportNestable>
-
-/**
- * A custom type for an item of a repeatable zone. This type of structure can be found in the 'primary' and 'items' fields of a slice or in the group field.
- *
- * @param fieldModels a record of all nestable widgets that can be used in the zone
- */
-export const RepeatableZoneItem = (
-	fieldModels: Record<WidgetKey, NestableWidget>,
-) =>
-	new t.Type<RepeatableZoneItem>(
-		"RepeatableZoneItem",
-		(u): u is RepeatableZoneItem =>
-			t.record(WidgetKey, t.unknown).is(u) &&
-			Object.values(u).reduce<boolean>(
-				(acc, value) => acc && ImportNestable.is(value),
-				true,
-			),
-		(u, c) => {
-			const codecEntries = Object.entries(fieldModels).map(
-				([key, model]) => [key, ImportNestable.getCodec(model)] as const,
-			)
-
-			const groupCodec = withCustomError(
-				t.partial({
-					...Object.fromEntries(codecEntries),
-				}),
-				() => "The value must be an object",
-			)
-
-			return pipe(
-				groupCodec.validate(u, c),
-				E.chain((decodedContent) => {
-					// Validate if all fields are present in the model
-					const keys = Object.keys(decodedContent)
-					const errors: t.Errors = keys.flatMap((key) =>
-						fieldModels[key]
-							? []
-							: [
-									{
-										value: decodedContent[key],
-										context: c,
-										message: `The field '${key}' is not defined in the custom type`,
-									},
-							  ],
-					)
-
-					return errors.length > 0
-						? t.failures(errors)
-						: t.success(decodedContent as RepeatableZoneItem) // We can never have a key with decoded value 'undefined' so we can ignore the type derived from t.partial
-				}),
-			)
-		},
-		t.identity,
-	)

package/src/import/validators/fields/UID.ts

@@ -1,27 +0,0 @@
-import * as t from "io-ts"
-
-import { String } from "../../../validators"
-import { ImportContent } from "./ImportContent"
-
-const regex = /^[a-z0-9-_.]+$/
-
-const uidValue = String.pipe(
-	new t.Type<string, string, string>(
-		"ImportUIDField",
-		(u: unknown): u is string => String.is(u),
-		(n: string, c: t.Context) => {
-			if (regex.test(n)) {
-				return t.success(n)
-			}
-			return t.failure(
-				n,
-				c,
-				"UID can only contain alphanumeric characters, dashes, underscores, and dots",
-			)
-		},
-		t.identity,
-	),
-)
-
-export const ImportUID = ImportContent("UID", uidValue)
-export type ImportUID = t.TypeOf<typeof ImportUID>

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

@@ -1,4 +0,0 @@
-export * from "./nestable"
-export * from "./RepeatableZone"
-export * from "./RepeatableZoneItem"
-export * from "./UID"

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

@@ -1,7 +0,0 @@
-import type { TypeOf } from "io-ts"
-
-import { Boolean, NullOrElse } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-
-export const ImportBoolean = ImportContent("Boolean", NullOrElse(Boolean))
-export type ImportBoolean = TypeOf<typeof ImportBoolean>

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

@@ -1,28 +0,0 @@
-import * as t from "io-ts"
-
-import { HexaColor, HexaColorCode } from "../../../../common/HexaColorCode"
-import { NullOrElse, String } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-
-const colorValue = new t.Type<HexaColorCode, HexaColorCode, string>(
-	"ImportColorValue",
-	(u: unknown): u is HexaColorCode => String.is(u) && HexaColor.is(u),
-	(s: string, c: t.Context) => {
-		if (!HexaColor.is(s)) {
-			return t.failure(
-				s,
-				c,
-				"The color value must be an hexadecimal color code",
-			)
-		}
-
-		return t.success(s)
-	},
-	t.identity,
-)
-
-export const ImportColor = ImportContent(
-	"Color",
-	NullOrElse(String.pipe(colorValue)),
-)
-export type ImportColor = t.TypeOf<typeof ImportColor>

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

@@ -1,34 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import { NullOrElse, String } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-const DATE_INPUT_REGEX = /^(\d{1,4})-(\d{1,2})-(\d{1,2})$/
-
-const dateValue = new t.Type<Date, Date, unknown>(
-	"ImportNumberValue",
-	(u: unknown): u is Date => u instanceof Date,
-	(u: unknown, c: t.Context) =>
-		pipe(
-			String.validate(u, c),
-			chain((s: string) => {
-				const date = new Date(s)
-				const isInvalidDate = isNaN(date.getTime())
-
-				if (isInvalidDate || !DATE_INPUT_REGEX.test(s)) {
-					return t.failure(
-						u,
-						c,
-						"The value must be a Date in the format YYYY-MM-DD",
-					)
-				}
-
-				return t.success(date)
-			}),
-		),
-	t.identity,
-)
-
-export const ImportDate = ImportContent("Date", NullOrElse(dateValue))
-export type ImportDate = t.TypeOf<typeof ImportDate>

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

@@ -1,41 +0,0 @@
-import * as t from "io-ts"
-
-import { EmptyObjectOrElse } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-
-type URL = string
-
-function isValidHttpUrl(param: unknown): param is URL {
-	try {
-		if (typeof param !== "string") {
-			return false
-		}
-		const url = new URL(param)
-		return ["http:", "https:"].includes(url.protocol)
-	} catch (err) {
-		return false
-	}
-}
-
-const EmbedUrl = new t.Type<URL, URL, unknown>(
-	"EmbedUrl",
-	(u: unknown): u is URL => isValidHttpUrl(u),
-	(u: unknown, c: t.Context) => {
-		if (isValidHttpUrl(u)) {
-			return t.success(u)
-		} else {
-			return t.failure(u, c, "The value must be a valid http/https url")
-		}
-	},
-	t.identity,
-)
-
-export const ImportEmbedValue = t.strict({
-	embed_url: EmbedUrl,
-})
-
-export const ImportEmbed = ImportContent(
-	"Embed",
-	EmptyObjectOrElse(ImportEmbedValue),
-)
-export type ImportEmbed = t.TypeOf<typeof ImportEmbed>

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

@@ -1,21 +0,0 @@
-import type { TypeOf } from "io-ts"
-import * as t from "io-ts"
-
-import { EmptyObjectOrElse, NumberRange } from "../../../../validators"
-import { withCustomError } from "../../../../validators/function"
-import { ImportContent } from "../ImportContent"
-
-const GeoPoint = withCustomError(
-	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(GeoPoint),
-)
-export type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>

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

@@ -1,22 +0,0 @@
-import * as t from "io-ts"
-
-import type { Image as ImageDefinition } from "../../../../../customtypes"
-import { EmptyObject } from "../../../../../validators"
-
-export const defaultImportImage = (field?: ImageDefinition) => {
-	// If there is not thumbnails we expect an empty object
-	if (!field?.config?.thumbnails || !field.config.thumbnails.length)
-		return EmptyObject
-
-	// If there are thumbnails, we can expect an object with thumbnails as empty objects,
-	// however we don't accept any other properties for the empty state
-	return t.strict(
-		field.config.thumbnails.reduce(
-			(acc, thumbnail) => ({
-				...acc,
-				[thumbnail.name]: EmptyObject,
-			}),
-			{},
-		),
-	)
-}

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

@@ -1,66 +0,0 @@
-import { map } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import type { Validation } from "io-ts"
-import * as t from "io-ts"
-
-import type { Image as ImageDefinition } from "../../../../../customtypes"
-import { DefaultOrElse } from "../../../../../validators"
-import { withCustomError } from "../../../../../validators/function"
-import { ImportContent } from "../../ImportContent"
-import { defaultImportImage } from "./default"
-import {
-	mergeImageViewWithCtConstraints,
-	mergeThumbnailsWithCtConstraints,
-} from "./merge"
-import type { ImageFieldWithThumbnails } from "./model"
-import { ImportImageWithThumbnails } from "./validators"
-
-/* For code clarity, the output of this validator will be simplified
- *
- *  Input -> type ImageAPIV2 = ImportImageView & ImportThumbnails
- *  Output -> type ImageWithThumbnails 👇
- */
-
-const ImageFieldCodec = (field?: ImageDefinition) => {
-	const ImageCodec = ImportImageWithThumbnails(field)
-	return new t.Type<ImageFieldWithThumbnails>(
-		"ImageField",
-		(u: unknown): u is ImageFieldWithThumbnails => ImageCodec.is(u),
-		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> =>
-			pipe(
-				ImageCodec.validate(u, ctx),
-				map((imageApiV2) => {
-					const { id, dimensions, edit, copyright, alt, ...thumbnails } =
-						imageApiV2
-
-					return {
-						...mergeImageViewWithCtConstraints(
-							imageApiV2,
-							imageApiV2,
-							field?.config?.constraint,
-						),
-						thumbnails: mergeThumbnailsWithCtConstraints(
-							thumbnails,
-							imageApiV2,
-							field,
-						),
-					}
-				}),
-			),
-		t.identity,
-	)
-}
-
-export const ImportImage = (field?: ImageDefinition) =>
-	ImportContent(
-		"Image",
-		withCustomError(
-			DefaultOrElse<Record<never, never>, ImageFieldWithThumbnails>(
-				defaultImportImage(field),
-			)(ImageFieldCodec(field)),
-			() => "An image field must be an object",
-		),
-	)
-export type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>
-
-export * from "./model"

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

@@ -1,64 +0,0 @@
-import type { Image } from "../../../../../customtypes"
-import type ImageConstraint from "../../../../../customtypes/widgets/shared/ImageConstraint"
-import type { ImageField } from "./model"
-import type { ImportImageView, ImportThumbnails } from "./validators"
-
-/* This function merges user input with custom type constraints.
- *  If a thumbnails' data are missing (`image`) then the default is used (`defaultImage`)
- */
-export const mergeImageViewWithCtConstraints = (
-	image: ImportImageView | undefined,
-	defaultImage: ImportImageView,
-	constraints: ImageConstraint | undefined,
-): ImageField => {
-	const background = image?.edit?.background
-	const width =
-		constraints?.width ??
-		image?.dimensions?.width ??
-		defaultImage?.dimensions?.width
-	const height =
-		constraints?.height ??
-		image?.dimensions?.height ??
-		defaultImage?.dimensions?.height
-	const alt = image?.alt
-	const copyright = image?.copyright
-
-	return {
-		id: image?.id ?? defaultImage?.id,
-		edit: {
-			x: image?.edit?.x ?? 0,
-			y: image?.edit?.y ?? 0,
-			zoom: image?.edit?.zoom ?? 1,
-			...(background !== undefined ? { background } : {}),
-		},
-		dimensions: {
-			...(width !== undefined ? { width } : {}),
-			...(height !== undefined ? { height } : {}),
-		},
-		...(alt !== undefined ? { alt } : {}),
-		...(copyright !== undefined ? { copyright } : {}),
-	}
-}
-
-/* This function handles each thumbnail defined in the custom type.
- *
- *  For each of them it merges the user input with custom type constraints.
- *
- *  If a thumbnail is missing, the data from the default image is used.
- */
-export const mergeThumbnailsWithCtConstraints = (
-	thumbnails: ImportThumbnails,
-	defaultImage: ImportImageView,
-	field?: Image,
-) =>
-	field?.config?.thumbnails?.reduce(
-		(acc, thumbnail) => ({
-			...acc,
-			[thumbnail.name]: mergeImageViewWithCtConstraints(
-				thumbnails[thumbnail.name],
-				defaultImage,
-				thumbnail,
-			),
-		}),
-		{},
-	) ?? {}

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

@@ -1,18 +0,0 @@
-export type ImageField = {
-	id: string
-	edit: {
-		x: number
-		y: number
-		zoom: number
-		background?: string
-	}
-	dimensions: {
-		width?: number
-		height?: number
-	}
-	copyright?: string | null
-	alt?: string | null
-}
-export type ImageFieldWithThumbnails = ImageField & {
-	thumbnails: Record<string, ImageField>
-}

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

@@ -1,70 +0,0 @@
-import * as t from "io-ts"
-
-import type {
-	Image as ImageDefinition,
-	Thumbnail,
-} from "../../../../../customtypes"
-import {
-	Number,
-	String,
-	StringOrNull,
-} from "../../../../../validators/BasicTypes"
-import { withCustomError } from "../../../../../validators/function"
-
-export const ImportImageViewShape = t.intersection([
-	t.type({
-		// Image Id
-		id: String,
-	}),
-	t.partial({
-		// Dimensions here will be used if they are not defined in the custom type
-		dimensions: withCustomError(
-			t.partial({
-				width: Number,
-				height: Number,
-			}),
-			() => "The value must be an object",
-		),
-		// Crop information
-		edit: withCustomError(
-			t.partial({
-				x: Number,
-				y: Number,
-				zoom: Number,
-				background: String,
-			}),
-			() => "The value must be an object",
-		),
-		// Copyrights and alt are set in the Asset by default but they can be overrided
-		copyright: StringOrNull,
-		alt: StringOrNull,
-	}),
-])
-
-export const ImportImageView = withCustomError(
-	ImportImageViewShape,
-	() => "The value must be an object",
-)
-export type ImportImageView = t.TypeOf<typeof ImportImageView>
-
-const ImportThumbnails = (thumbnails: readonly Thumbnail[]) =>
-	t.partial(
-		thumbnails.reduce<Record<string, typeof ImportImageView>>(
-			(acc, thumbnail) => ({
-				...acc,
-				[thumbnail.name]: ImportImageView,
-			}),
-			{},
-		),
-	) as t.Type<Record<string, ImportImageView>>
-
-export type ImportThumbnails = t.TypeOf<ReturnType<typeof ImportThumbnails>>
-
-export const ImportImageWithThumbnails = (def?: ImageDefinition) =>
-	withCustomError(
-		t.intersection([
-			ImportImageViewShape,
-			ImportThumbnails(def?.config?.thumbnails ?? []),
-		]),
-		() => "The value must be an object",
-	)

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

@@ -1,39 +0,0 @@
-import * as t from "io-ts"
-
-import { withCustomError } from "../../../../../validators/function"
-import {
-	ImportBlockType,
-	ImportEmbedBlock,
-	ImportImageBlock,
-	ImportTextBlock,
-} from "./blocks"
-
-export type ImportBlock = ImportTextBlock | ImportImageBlock | ImportEmbedBlock
-
-export const ImportBlock = (allowedBlockTypes: string[]) =>
-	withCustomError(
-		t
-			.type({
-				type: ImportBlockType(allowedBlockTypes),
-			})
-			.pipe(
-				new t.Type<ImportBlock, ImportBlock, { type: ImportBlockType }>(
-					"ImportBlock",
-					(u): u is ImportBlock =>
-						t
-							.union([ImportTextBlock, ImportImageBlock, ImportEmbedBlock])
-							.is(u),
-					(u, c) => {
-						if (u.type === "image") {
-							return ImportImageBlock.validate(u, c)
-						} else if (u.type === "embed") {
-							return ImportEmbedBlock.validate(u, c)
-						} else {
-							return ImportTextBlock.validate(u, c)
-						}
-					},
-					t.identity,
-				),
-			),
-		() => "Rich text block must be an object",
-	)

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

@@ -1,54 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import type { RichText as RichTextCustomType } from "../../../../../customtypes"
-import { EmptyArrayOrElse } from "../../../../../validators"
-import { withCustomError } from "../../../../../validators/function"
-import { ImportContent } from "../../ImportContent"
-import { ImportBlock } from "./ImportBlock"
-
-export const ImportRichText = (customType?: RichTextCustomType) => {
-	const single = customType?.config?.single?.split(",")
-	const multi = customType?.config?.multi?.split(",")
-	const allowedBlockTypes = multi || single
-
-	const isSingleBlockAllowed = multi === undefined && single !== undefined
-
-	const BlockCodec = ImportBlock(allowedBlockTypes ?? [])
-	const RichTextArrayCodec = withCustomError(
-		t.array(BlockCodec),
-		() => "Rich text field must be an array",
-	)
-
-	return ImportContent(
-		"StructuredText",
-		EmptyArrayOrElse(
-			new t.ArrayType<typeof BlockCodec, ImportBlock[], ImportBlock[]>(
-				RichTextArrayCodec.name,
-				(u): u is ImportBlock[] => RichTextArrayCodec.is(u),
-				(u, c) => {
-					if (allowedBlockTypes === undefined) {
-						throw new Error(
-							"Invalid custom type for the rich text field: the model is missing a 'single' or 'multi' field defining a list of allowed block types",
-						)
-					}
-
-					return pipe(
-						RichTextArrayCodec.validate(u, c),
-						E.chain((blocks) => {
-							if (isSingleBlockAllowed && blocks.length > 1) {
-								return t.failure(blocks, c, "This field only allows one block")
-							}
-							return t.success(blocks)
-						}),
-					)
-				},
-				t.identity,
-				BlockCodec,
-			),
-		),
-	)
-}
-
-export type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>

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

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

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

@@ -1,17 +0,0 @@
-import * as t from "io-ts"
-
-import { ImportImageView } from "../../Image/validators"
-
-export const ImportImageBlockType = t.literal("image")
-export type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>
-
-export const ImportImageBlock = t.exact(
-	t.intersection([
-		t.type({
-			type: ImportImageBlockType,
-		}),
-		ImportImageView,
-	]),
-)
-
-export type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>