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

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

@@ -1,55 +0,0 @@
-import type { Asset } from "../../../../common"
-import type { Embed } from "../../../../common/Embed"
-import type { NestableContent } from "../../../../content"
-import type { ImportNestable } from "../../../validators"
-import {
-	booleanConverter,
-	colorConverter,
-	dateConverter,
-	embedConverter,
-	geopointConverter,
-	imageConverter,
-	linkConverter,
-	numberConverter,
-	richTextConverter,
-	selectConverter,
-	textConverter,
-	timestampConverter,
-} from "."
-
-export function convertNestableWidget(
-	field: ImportNestable,
-	assets: Record<Asset["id"], Asset | undefined>,
-	embeds: Record<string, Embed | undefined>,
-): NestableContent | undefined {
-	switch (field.type) {
-		case "Boolean":
-			return booleanConverter(field.value)
-		case "Color":
-			return colorConverter(field.value)
-		case "Select":
-			return selectConverter(field.value)
-		case "Number":
-			return numberConverter(field.value)
-		case "Text":
-			return textConverter(field.value)
-		case "Date":
-			return dateConverter(field.value)
-		case "Timestamp":
-			return timestampConverter(field.value)
-		case "Embed":
-			return embedConverter(field.value, embeds)
-		case "GeoPoint":
-			return geopointConverter(field.value)
-		case "Link":
-			return linkConverter(field.value, assets)
-		case "Image":
-			return imageConverter(field.value, assets)
-		case "StructuredText":
-			return richTextConverter(field.value, assets, embeds)
-		default:
-			throw new Error(
-				`Unsupported type of nestable converter ${JSON.stringify(field)}`,
-			)
-	}
-}

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

@@ -1,14 +0,0 @@
-import type { NumberContent } from "../../../../content"
-import type { ImportNumber } from "../../../validators"
-
-export const numberConverter = (
-	field: ImportNumber["value"],
-): NumberContent | undefined => {
-	if (field === null) return
-
-	return {
-		type: "Number",
-		value: field.toString(),
-		__TYPE__: "FieldContent",
-	}
-}

package/src/import/converters/fields/nestable/RichText/embedBlock.ts

@@ -1,17 +0,0 @@
-import type { Embed } from "../../../../../common"
-import type { EmbedBlock } from "../../../../../content"
-import type { ImportEmbedBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
-import { embedConverter } from "../Embed"
-
-export function embedBlockConverter(
-	block: ImportEmbedBlock,
-	embeds: Record<string, Embed | undefined>,
-): EmbedBlock {
-	const embedData = embedConverter(block.oembed, embeds)
-
-	if (!embedData) throw new Error("Failed to convert embed data")
-	return {
-		type: block.type,
-		data: embedData,
-	}
-}

package/src/import/converters/fields/nestable/RichText/imageBlock.ts

@@ -1,17 +0,0 @@
-import { Asset, getAssetOrThrow } from "../../../../../common"
-import type { ImageBlock } from "../../../../../content"
-import type { ImportImageBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
-import { convertImageView } from "../Image"
-
-export function imageBlockConverter(
-	block: ImportImageBlock,
-	assets: Record<Asset["id"], Asset | undefined>,
-): ImageBlock {
-	return {
-		type: block.type,
-		data: convertImageView<ImportImageBlock>(
-			block,
-			getAssetOrThrow(assets)(block.id),
-		),
-	}
-}

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

@@ -1,23 +0,0 @@
-import type { Asset, Embed } from "../../../../../common"
-import type { RichTextContent } from "../../../../../content"
-import { RichTextContentType } from "../../../../../content"
-import type { ImportRichText } from "../../../../validators"
-import { embedBlockConverter } from "./embedBlock"
-import { imageBlockConverter } from "./imageBlock"
-import { textBlockConverter } from "./textBlock"
-
-export const richTextConverter = (
-	richTextField: ImportRichText["value"],
-	assets: Record<Asset["id"], Asset | undefined>,
-	embeds: Record<string, Embed | undefined>,
-): RichTextContent | undefined => {
-	if (richTextField === null) return
-	return {
-		__TYPE__: RichTextContentType,
-		value: richTextField.map((block) => {
-			if (block.type === "image") return imageBlockConverter(block, assets)
-			else if (block.type === "embed") return embedBlockConverter(block, embeds)
-			return textBlockConverter(block, assets)
-		}),
-	}
-}

package/src/import/converters/fields/nestable/RichText/textBlock.ts

@@ -1,62 +0,0 @@
-import type { Asset } from "../../../../../common"
-import type { Span, TextBlock } from "../../../../../content"
-import type { ImportTextBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
-import { linkConverter } from "../Link"
-
-export function textBlockConverter(
-	block: ImportTextBlock,
-	assets: Record<Asset["id"], Asset | undefined>,
-): TextBlock {
-	return {
-		type: block.type,
-		content: {
-			text: block.text,
-			...(() => {
-				if (block.spans) {
-					const convertedSpans = spansConverter(block.spans, assets)
-					if (!convertedSpans) return {}
-
-					return { spans: convertedSpans }
-				}
-				return {}
-			})(),
-		},
-		...(block.direction ? { direction: block.direction } : {}),
-	}
-}
-
-function spansConverter(
-	spans: NonNullable<ImportTextBlock["spans"]>,
-	assets: Record<Asset["id"], Asset | undefined>,
-): Span[] {
-	return spans.reduce<Span[]>((acc, span) => {
-		switch (span.type) {
-			case "em":
-			case "strong":
-				return [...acc, span]
-			case "label":
-				return [
-					...acc,
-					{
-						...span,
-						data: span.data.label,
-					},
-				]
-
-			case "hyperlink": {
-				const convertedLink = linkConverter(span.data, assets)
-				if (!convertedLink) return acc
-
-				return [
-					...acc,
-					{
-						type: span.type,
-						start: span.start,
-						end: span.end,
-						data: convertedLink.value,
-					},
-				]
-			}
-		}
-	}, [])
-}

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

@@ -1,14 +0,0 @@
-import type { SelectContent } from "../../../../content"
-import type { ImportSelect } from "../../../validators"
-
-export const selectConverter = (
-	field: ImportSelect["value"],
-): SelectContent | undefined => {
-	if (field === null) return
-
-	return {
-		type: "Select",
-		value: field,
-		__TYPE__: "FieldContent",
-	}
-}

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

@@ -1,14 +0,0 @@
-import type { TextContent } from "../../../../content"
-import type { ImportText } from "../../../validators"
-
-export const textConverter = (
-	field: ImportText["value"],
-): TextContent | undefined => {
-	if (field === null) return
-
-	return {
-		type: "Text",
-		value: field,
-		__TYPE__: "FieldContent",
-	}
-}

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

@@ -1,14 +0,0 @@
-import type { TimestampContent } from "../../../../content"
-import type { ImportTimestamp } from "../../../validators"
-
-export const timestampConverter = (
-	field: ImportTimestamp["value"],
-): TimestampContent | undefined => {
-	if (field === null) return
-
-	return {
-		type: "Timestamp",
-		value: field.toISOString(),
-		__TYPE__: "FieldContent",
-	}
-}

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

@@ -1,13 +0,0 @@
-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 "./RichText"
-export * from "./Select"
-export * from "./Text"
-export * from "./Timestamp"

package/src/import/converters/index.ts

@@ -1,2 +0,0 @@
-export * from "./Document"
-export * from "./fields"

package/src/import/index.ts

@@ -1,2 +0,0 @@
-export * from "./converters"
-export * from "./validators"

package/src/import/validators/Document.ts

@@ -1,103 +0,0 @@
-import { either } from "fp-ts"
-import { Either, isLeft } from "fp-ts/Either"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import type { WidgetKey } from "../../common"
-import type { StaticCustomType, StaticWidget } from "../../customtypes"
-import { flattenCustomTypeFields } from "../../customtypes"
-import { isObject } from "../../utils/Objects"
-import { withCustomError } from "../../validators/function"
-import { ImportField } from "./fields/ImportField"
-
-const rawImportDocument = withCustomError(
-	t.UnknownRecord,
-	() => "document is not an object",
-)
-
-function validateField(
-	document: Record<string, unknown>,
-	customType: StaticCustomType,
-) {
-	return (
-		key: string,
-		content: unknown,
-		model?: StaticWidget,
-	): Either<t.Errors, ImportField> => {
-		// the field is not defined in the custom type -> extra field or typo
-		if (!model) {
-			const error: t.ValidationError = {
-				value: content,
-				context: [{ key: key, type: t.unknown }],
-				message: `The field ${key} is not part of the Custom type`,
-			}
-			return either.left([error])
-		}
-
-		// retrieving the right codec then testing out fieldValue with it.
-		const { result, codec } = ImportField.decode(model)(content)
-
-		// error.context is pointing at root when it should point to a `fieldKey`.
-		// We need to override the context to make it right.
-		if (isLeft(result)) {
-			const errors: t.Errors = result.left.map((error) => {
-				const contextHead = error.context[0]
-				const context = [
-					{ key: "", actual: document, type: ImportDocument(customType) },
-					contextHead
-						? { ...contextHead, key: key }
-						: { key: key, actual: content, type: codec },
-					...error.context.slice(1),
-				]
-
-				return { ...error, context }
-			})
-			return either.left(errors)
-		}
-		return either.right(result.right)
-	}
-}
-
-function validateDocument(
-	customType: StaticCustomType,
-	rawDoc: Record<string, unknown>,
-) {
-	const fieldModels = flattenCustomTypeFields(customType)
-	const { document, errors } = Object.entries(rawDoc).reduce<{
-		document: ImportDocument
-		errors: t.Errors
-	}>(
-		(acc, [fieldKey, fieldValue]) => {
-			const parsedField = validateField(rawDoc, customType)(
-				fieldKey,
-				fieldValue,
-				fieldModels[fieldKey],
-			)
-
-			if (isLeft(parsedField))
-				return { ...acc, errors: [...acc.errors, ...parsedField.left] }
-
-			return {
-				...acc,
-				document: { ...acc.document, [fieldKey]: parsedField.right },
-			}
-		},
-		{ document: {}, errors: [] },
-	)
-	if (errors.length > 0) return either.left(errors)
-	return either.right(document)
-}
-
-export type ImportDocument = Record<WidgetKey, ImportField>
-export const ImportDocument = (customType: StaticCustomType) =>
-	new t.Type<ImportDocument, ImportDocument, unknown>(
-		"ImportDocument",
-		(u): u is ImportDocument => isObject(u),
-		(raw: unknown) => {
-			return pipe(
-				rawImportDocument.decode(raw),
-				either.chain((doc) => validateDocument(customType, doc)),
-			)
-		},
-		t.identity,
-	)

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

@@ -1,30 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import type { FieldType } from "../../../customtypes"
-import { isObject } from "../../../utils/Objects"
-
-export const ImportContent = <T extends FieldType, A, O = A>(
-	type: T,
-	valueCodec: t.Type<A, O>,
-) =>
-	new t.Type<{ type: T; value: A }, O>(
-		`ImportField: ${valueCodec.name}`,
-		(u: unknown): u is { type: T; value: A } => {
-			if (!isObject(u)) return false
-			return type === u["type"] && valueCodec.is(u["value"])
-		},
-		(u: unknown, c) => {
-			return pipe(
-				valueCodec.validate(u, c),
-				either.map((decodedValue) => {
-					return {
-						type,
-						value: decodedValue,
-					}
-				}),
-			)
-		},
-		(field) => field.value as unknown as O,
-	)

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

@@ -1,36 +0,0 @@
-import type { StaticWidget } from "../../../customtypes"
-import { ImportGroup } from "./ImportGroup"
-import { ImportSlices } from "./ImportSlices"
-import { ImportNestable } from "./nestable"
-
-export type ImportField = ImportSlices | ImportNestable | ImportGroup
-
-export const ImportField = {
-	is(u: unknown): u is ImportField {
-		return ImportField.is(u)
-	},
-	decode: (field: StaticWidget) => {
-		return (content: unknown) => {
-			switch (field.type) {
-				case "UID":
-					throw new Error(
-						`The field '${field.type}' should be put at the root level of the document`,
-					)
-				case "Slices":
-					return {
-						codec: ImportSlices(field),
-						result: ImportSlices(field).decode(content),
-					}
-				case "Group":
-					return {
-						codec: ImportGroup(field),
-						result: ImportGroup(field).decode(content),
-					}
-				case "Choice":
-					throw new Error(`Unsupported type of field ${field.type}`)
-				default:
-					return ImportNestable.decode(field)(content)
-			}
-		}
-	},
-}

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

@@ -1,45 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import type { Group } from "../../../customtypes"
-import { EmptyArrayOrElse } from "../../../validators"
-import { withCustomError } from "../../../validators/function"
-import { ImportContent } from "./ImportContent"
-import { RepeatableZone } from "./RepeatableZone"
-
-export const ImportGroupValue = (groupCustomType?: Group) => {
-	const fieldsModel = groupCustomType?.config?.fields ?? {}
-	const groupArrayCodec = RepeatableZone(fieldsModel)
-
-	return withCustomError(
-		new t.Type<RepeatableZone>(
-			groupArrayCodec.name,
-			groupArrayCodec.is,
-			(u, c) =>
-				pipe(
-					groupArrayCodec.validate(u, c),
-					E.chain((groups) => {
-						if (
-							groupCustomType?.config?.repeat === false &&
-							groups.length > 1
-						) {
-							return t.failure(
-								groups,
-								c,
-								"The custom type for this group field does not allow multiple group items",
-							)
-						}
-						return t.success(groups)
-					}),
-				),
-			t.identity,
-		),
-		() => "The group field value must be an array",
-	)
-}
-
-export const ImportGroup = (groupCustomType?: Group) =>
-	ImportContent("Group", EmptyArrayOrElse(ImportGroupValue(groupCustomType)))
-
-export type ImportGroup = t.TypeOf<ReturnType<typeof ImportGroup>>

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

@@ -1,56 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import type { StaticSlices } from "../../../../customtypes"
-import { EmptyArrayOrElse } from "../../../../validators"
-import { ImportContent } from "../ImportContent"
-import { SharedSlice } from "./SharedSlice"
-import {
-	extractSupportedSlices,
-	findImportSharedSliceDuplicateIds,
-} from "./utils"
-
-export const ImportSlices = (staticSlices: StaticSlices) => {
-	const supportedSlices = extractSupportedSlices(staticSlices)
-
-	// For now we only support the SharedSlice, however if we want to support more in the future
-	// we would have to change the codec here to something like this: t.array(t.union([ImportSharedSlice(sharedSlices), NewSliceCodec(newSliceCustomTypes)])).
-	const SharedSliceCodec = SharedSlice(supportedSlices)
-	const SlicesArrayCodec = t.array(SharedSliceCodec)
-
-	return ImportContent(
-		"Slices",
-		EmptyArrayOrElse(
-			new t.ArrayType<typeof SharedSliceCodec, SharedSlice[]>(
-				SlicesArrayCodec.name,
-				(u): u is SharedSlice[] => SlicesArrayCodec.is(u),
-				(u, c) => {
-					return pipe(
-						SlicesArrayCodec.validate(u, c),
-						E.chain((slices) => {
-							// This part might not make sense for all Slice types in the future, but for now we only support the SharedSlice
-							// In case we support more in the future, we would have to filter only the relevant type for this check
-							const sharedSliceDuplicates =
-								findImportSharedSliceDuplicateIds(slices)
-							if (sharedSliceDuplicates.length > 0) {
-								return t.failure(
-									slices,
-									[],
-									`Duplicate slice IDs detected: ${sharedSliceDuplicates.join(
-										", ",
-									)}`,
-								)
-							}
-							return t.success(slices)
-						}),
-					)
-				},
-				t.identity,
-				SharedSliceCodec,
-			),
-		),
-	)
-}
-
-export type ImportSlices = t.TypeOf<ReturnType<typeof ImportSlices>>

package/src/import/validators/fields/ImportSlices/SharedSlice/SharedSlice.ts

@@ -1,104 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes"
-import { NonEmptyString, String } from "../../../../../validators"
-import { RepeatableZone } from "../../RepeatableZone"
-import { RepeatableZoneItem } from "../../RepeatableZoneItem"
-import {
-	OptionalSharedSliceId,
-	SharedSliceId,
-	SharedSliceType,
-	SharedSliceVariation,
-} from "./fields"
-
-export type SharedSlice = {
-	id: SharedSliceId | null | undefined
-	slice_type: string
-	name: string
-	variation: string
-	primary: RepeatableZoneItem | null | undefined
-	items: RepeatableZone | null | undefined
-	slice_label: string | null | undefined
-	version: string | null | undefined
-}
-
-const SharedSliceShape = t.strict({
-	id: OptionalSharedSliceId,
-	slice_type: NonEmptyString,
-	name: String,
-	variation: NonEmptyString,
-	primary: t.union([t.undefined, t.null, t.record(NonEmptyString, t.unknown)]),
-	items: t.union([
-		t.undefined,
-		t.null,
-		t.array(t.record(NonEmptyString, t.unknown)),
-	]),
-	slice_label: t.union([t.undefined, t.null, String]),
-	version: t.union([t.undefined, t.null, String]),
-})
-
-export const SharedSlice = (sharedSlices: SharedSliceCustomType[]) =>
-	new t.Type<SharedSlice>(
-		"SharedSlice",
-		(u): u is SharedSlice => SharedSliceShape.is(u),
-		(u, c) =>
-			pipe(
-				// We validate the base fields that we can validate directly based on the provided 'sharedSlices'
-				t
-					.type({
-						id: OptionalSharedSliceId,
-						slice_type: SharedSliceType(sharedSlices),
-						slice_label: t.union([t.undefined, t.null, String]),
-						version: t.union([t.undefined, t.null, String]),
-					})
-					.validate(u, c),
-				E.chain((decoded) =>
-					pipe(
-						// We validate the 'variation' field, for which we need the SharedSlice custom type retrieved in the first step
-						t
-							.type({
-								variation: SharedSliceVariation(decoded.slice_type.data),
-							})
-							.validate(u, c),
-						E.map(({ variation }) => ({ ...decoded, variation })),
-					),
-				),
-				E.chain((decoded) =>
-					pipe(
-						// We validate the 'primary' and 'items' content fields, for which we need the Variation custom type retrieved in the previous step
-						t
-							.partial({
-								primary: RepeatableZoneItem(
-									decoded.variation.data.primary ?? {},
-								),
-								items: RepeatableZone(decoded.variation.data.items ?? {}),
-							})
-							.validate(u, c),
-						E.map(({ primary, items }) => ({ ...decoded, primary, items })),
-					),
-				),
-				E.map(
-					({
-						id,
-						slice_type,
-						variation,
-						primary,
-						items,
-						slice_label,
-						version,
-					}) => ({
-						id,
-						slice_type: slice_type.slice_type,
-						name: slice_type.data.name,
-						variation: variation.variation,
-						primary,
-						items,
-						slice_label,
-						version: version ?? variation.data.version,
-					}),
-				),
-			),
-		t.identity,
-	)

package/src/import/validators/fields/ImportSlices/SharedSlice/errors.ts

@@ -1,6 +0,0 @@
-export const SharedSliceErrors = {
-	SliceTypeNotFound: (slice_type: string) =>
-		`Shared slice '${slice_type}' not found in this slice zone in the document's custom type`,
-	VariationNotFound: (variation: string, slice_type: string) =>
-		`Variation '${variation}' not found for Slice '${slice_type}'`,
-} as const

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/OptionalSharedSliceId.ts

@@ -1,20 +0,0 @@
-import * as t from "io-ts"
-
-import { SharedSliceId } from "./SharedSliceId"
-
-// Wrapping the 'SharedSliceId' codec in an optional codec here for the sake of error reporting.
-// When using t.union([t.undefined, t.null, SharedSliceId]) we get a nested error context
-// with the actual decoding error at position 2 in the context array.
-// To avoid mutating the error context we create this new wrapper codec so that  the error context will always have desired depth.
-export const OptionalSharedSliceId = new t.Type<
-	SharedSliceId | null | undefined
->(
-	"OptionalSharedSliceId",
-	(u): u is SharedSliceId | null | undefined =>
-		u === null || u === undefined || SharedSliceId.is(u),
-	(u, c) => {
-		if (u === null || u === undefined) return t.success(u)
-		return SharedSliceId.validate(u, c)
-	},
-	t.identity,
-)