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

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

@@ -1,45 +0,0 @@
-import * as t from "io-ts"
-
-import {
-	Number,
-	String,
-	StringOrNull,
-} from "../../../../../validators/BasicTypes"
-import { withCustomError } from "../../../../../validators/function"
-
-export const ImportImageView = withCustomError(
-	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,
-		}),
-	]),
-	() => "The value must be an object",
-)
-export type ImportImageView = t.TypeOf<typeof ImportImageView>
-
-export const ImportThumbnails = t.record(t.string, ImportImageView)
-export type ImportThumbnails = t.TypeOf<typeof ImportThumbnails>

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>

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

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

@@ -1,48 +0,0 @@
-import * as t from "io-ts"
-
-import { withCustomError } from "../../../../../../validators/function"
-import {
-	HyperlinkSpan,
-	HyperlinkSpanType,
-	TextSpan,
-	TextSpanType,
-} from "./spans"
-import { LabelSpan, LabelSpanType } from "./spans/LabelSpan"
-
-const SpanType = withCustomError(
-	t.union([HyperlinkSpanType, TextSpanType, LabelSpanType]),
-	() =>
-		`Span 'type' field must be specified and have one of the following values: ${[
-			...Object.keys(TextSpanType.keys),
-			LabelSpanType.value,
-		].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, LabelSpan])
-
-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 if (LabelSpanType.is(u.type)) {
-				return LabelSpan.validate(u, c)
-			} else {
-				return TextSpan.validate(u, c)
-			}
-		},
-		t.identity,
-	),
-)

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

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

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

@@ -1,24 +0,0 @@
-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/LabelSpan.ts

@@ -1,19 +0,0 @@
-import * as t from "io-ts"
-
-import { SpanLocation } from "./SpanLocation"
-
-export const LabelSpanType = t.literal("label")
-
-export const LabelSpan = t.exact(
-	t.intersection([
-		t.type({
-			type: LabelSpanType,
-			data: t.strict({
-				label: t.string,
-			}),
-		}),
-		SpanLocation,
-	]),
-)
-
-export type LabelSpan = t.TypeOf<typeof LabelSpan>

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

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

@@ -1,24 +0,0 @@
-import * as t from "io-ts"
-
-import { SpanLocation } from "./SpanLocation"
-
-const TextSpanTypes = {
-	Strong: "strong",
-	Em: "em",
-} as const
-
-export const TextSpanType = t.keyof({
-	[TextSpanTypes.Strong]: null,
-	[TextSpanTypes.Em]: 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

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

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

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

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

@@ -1,59 +0,0 @@
-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,88 +0,0 @@
-import type { NestableWidget } from "../../../../customtypes"
-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"
-import { ImportTimestamp } from "./Timestamp"
-
-export type ImportNestable =
-	| ImportBoolean
-	| ImportColor
-	| ImportNumber
-	| ImportSelect
-	| ImportText
-	| ImportDate
-	| ImportTimestamp
-	| ImportEmbed
-	| ImportLink
-	| ImportGeoPoint
-	| ImportImage
-	| ImportRichText
-
-const getCodecOrThrow = (field: NestableWidget) => {
-	switch (field.type) {
-		case "Boolean":
-			return ImportBoolean
-		case "Color":
-			return ImportColor
-		case "Number":
-			return ImportNumber(field)
-		case "Select":
-			return ImportSelect(field)
-		case "Text":
-			return ImportText
-		case "Date":
-			return ImportDate
-		case "Timestamp":
-			return ImportTimestamp
-		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}`)
-	}
-}
-
-export const ImportNestable = {
-	is(u: unknown): u is ImportNestable {
-		return (
-			ImportBoolean.is(u) ||
-			ImportColor.is(u) ||
-			ImportNumber().is(u) ||
-			ImportSelect().is(u) ||
-			ImportText.is(u) ||
-			ImportDate.is(u) ||
-			ImportTimestamp.is(u) ||
-			ImportEmbed.is(u) ||
-			ImportLink.is(u) ||
-			ImportGeoPoint.is(u) ||
-			ImportImage().is(u) ||
-			ImportRichText().is(u)
-		)
-	},
-	decode: (field: NestableWidget) => {
-		return (content: unknown) => {
-			const codec = getCodecOrThrow(field)
-			return {
-				codec,
-				result: codec.decode(content),
-			}
-		}
-	},
-
-	getCodec: getCodecOrThrow,
-}

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

@@ -1,38 +0,0 @@
-import * as t from "io-ts"
-
-import type {
-	Number as NumberField,
-	NumberConfig,
-} from "../../../../customtypes"
-import { NullOrElse, Number } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-
-const numberValue = (config?: NumberConfig) =>
-	Number.pipe(
-		new t.Type<number, number, number>(
-			"ImportNumberValue",
-			(u: unknown): u is number => Number.is(u),
-			(n: number, c: t.Context) => {
-				const min = config?.min
-				const max = config?.max
-
-				if ((min !== undefined && n < min) || (max !== undefined && n > max)) {
-					return t.failure(
-						n,
-						c,
-						`The value must be between [${min !== undefined ? min : ""}, ${
-							max !== undefined ? max : ""
-						}]`,
-					)
-				}
-
-				return t.success(n)
-			},
-			t.identity,
-		),
-	)
-
-export const ImportNumber = (field?: NumberField) =>
-	ImportContent("Number", NullOrElse(numberValue(field?.config)))
-
-export type ImportNumber = t.TypeOf<ReturnType<typeof ImportNumber>>

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

@@ -1,38 +0,0 @@
-import * as t from "io-ts"
-
-import type { Select, SelectConfig } from "../../../../customtypes"
-import { NullOrElse, String } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-
-const selectValue = (config?: SelectConfig) =>
-	String.pipe(
-		new t.Type<string, string, string>(
-			"ImportSelectValue",
-			(u: unknown): u is string => String.is(u),
-			(s: string, c: t.Context) => {
-				if (!config?.options) {
-					return t.failure(
-						s,
-						c,
-						"The value must be defined in the custom type's configuration of the field",
-					)
-				}
-
-				if (!config.options.includes(s)) {
-					return t.failure(
-						s,
-						c,
-						`The value must be one of these: ${config.options?.join(",")}`,
-					)
-				}
-
-				return t.success(s)
-			},
-			t.identity,
-		),
-	)
-
-export const ImportSelect = (field?: Select) =>
-	ImportContent("Select", NullOrElse(selectValue(field?.config)))
-
-export type ImportSelect = t.TypeOf<ReturnType<typeof ImportSelect>>

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

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