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

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>

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

@@ -1,39 +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"
-
-export const TIMESTAMP_INPUT_REGEX =
-	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:(?:[+-]{1}\d{2}:?\d{2})|Z)$/
-
-const timestampValue = new t.Type<Date, Date, unknown>(
-	"ImportTimestampValue",
-	(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 || !TIMESTAMP_INPUT_REGEX.test(s)) {
-					return t.failure(
-						u,
-						c,
-						"The value must be a DateTime in the format YYYY-MM-DDTHH:MM:SS+0000",
-					)
-				}
-
-				return t.success(date)
-			}),
-		),
-	t.identity,
-)
-
-export const ImportTimestamp = ImportContent(
-	"Timestamp",
-	NullOrElse(timestampValue),
-)
-export type ImportTimestamp = t.TypeOf<typeof ImportTimestamp>

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

@@ -1,14 +0,0 @@
-export * from "./Boolean"
-export * from "./Color"
-export * from "./Date"
-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"
-export * from "./Text"
-export * from "./Timestamp"

package/src/import/validators/index.ts

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