@prismicio/types-internal 3.17.0 → 4.0.0-canary.72def6d

package/src/content/legacy/empty.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const EmptyLegacySchema = z.union([
+	z.null(),
+	z.object({
+		value: z.null(),
+	}),
+])
+
+export type EmptyLegacy = z.infer<typeof EmptyLegacySchema>

package/src/content/legacy/field.ts

@@ -0,0 +1,8 @@
+import { z } from "zod/mini"
+
+export const StringLegacySchema = z.pipe(
+	z.string(),
+	z.transform((s: string) => s.trim()),
+)
+
+export type StringLegacy = z.infer<typeof StringLegacySchema>

package/src/content/legacy/geopoint.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const GeoPointLegacySchema = z.object({
+	position: z.object({
+		lat: z.number(),
+		lng: z.number(),
+	}),
+})
+
+export type GeoPointLegacy = z.infer<typeof GeoPointLegacySchema>

package/src/content/legacy/group.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+import { NestableLegacySchema } from "./nestable"
+
+export const GroupItemLegacySchema = z.record(z.string(), z.unknown())
+
+export type GroupItemLegacy = z.infer<typeof GroupItemLegacySchema>
+
+export const GroupLegacySchema = z.array(z.union([GroupItemLegacySchema, z.null()]))
+
+export type GroupLegacy = z.infer<typeof GroupLegacySchema>
+
+export const NestableAndGroupLegacySchema = z.union([NestableLegacySchema, GroupLegacySchema])
+
+export type NestableAndGroupLegacy = z.infer<typeof NestableAndGroupLegacySchema>

package/src/content/legacy/image.ts

@@ -0,0 +1,43 @@
+import { z } from "zod/mini"
+
+const OriginSchema = z.object({
+	id: z.string(),
+	url: z.string(),
+	width: z.number(),
+	height: z.number(),
+})
+
+const CropSchema = z.object({
+	x: z.number(),
+	y: z.number(),
+})
+
+const EditSchema = z.object({
+	zoom: z.number(),
+	crop: CropSchema,
+	background: z.string(),
+})
+
+const NonEmptyStringOrNullSchema = z.pipe(
+	z.nullish(z.string()),
+	z.transform((value) => (typeof value === "string" && value.length > 0 ? value : null)),
+)
+
+export const ImageViewLegacySchema = z.object({
+	origin: OriginSchema,
+	width: z.number(),
+	height: z.number(),
+	edit: EditSchema,
+	url: z.optional(z.string()),
+	credits: z.optional(NonEmptyStringOrNullSchema),
+	alt: z.optional(NonEmptyStringOrNullSchema),
+	provider: z.nullish(z.string()),
+})
+
+export type ImageLegacyView = z.infer<typeof ImageViewLegacySchema>
+
+export const ImageLegacySchema = z.extend(ImageViewLegacySchema, {
+	thumbnails: z.optional(z.record(z.string(), ImageViewLegacySchema)),
+})
+
+export type ImageLegacy = z.infer<typeof ImageLegacySchema>

package/src/content/legacy/integrationField.ts

@@ -0,0 +1,5 @@
+import { z } from "zod/mini"
+
+export const IntegrationFieldLegacySchema = z.string()
+
+export type IntegrationFieldLegacy = z.infer<typeof IntegrationFieldLegacySchema>

package/src/content/legacy/link.ts

@@ -0,0 +1,171 @@
+import { z } from "zod/mini"
+
+import { NonEmptyStringSchema } from "../../common/nonEmptyString"
+
+export const LinkKind = {
+	Image: "image",
+	File: "file",
+	Media: "media",
+	Document: "document",
+	External: "web",
+	Any: "any",
+} as const
+
+export const LinkType = {
+	Image: "ImageLink",
+	File: "FileLink",
+	Document: "DocumentLink",
+	External: "ExternalLink",
+	Media: "MediaLink",
+	Any: "AnyLink",
+} as const
+
+// Image
+export const FilledImageLinkValueLegacySchema = z.strictObject({
+	// `kind` was normalized to the literal (legacy behavior)
+	kind: z.pipe(
+		z.string(),
+		z.transform(() => LinkKind.Image),
+	),
+	id: z.string(),
+	url: z.string(),
+	height: z.string(),
+	width: z.string(),
+	size: z.string(),
+	name: z.string(),
+	date: z.nullish(z.string()),
+})
+
+export const EmptyImageLinkValueLegacySchema = z.strictObject({
+	kind: z.literal(LinkKind.Image),
+})
+
+// File
+export const FilledFileLinkValueLegacySchema = z.strictObject({
+	// `kind` was normalized to the literal (legacy behavior)
+	kind: z.pipe(
+		z.string(),
+		z.transform(() => LinkKind.File),
+	),
+	id: z.string(),
+	url: z.string(),
+	name: z.string(),
+	size: z.transform((value) => (typeof value === "string" ? value : "0")),
+	date: z.nullish(z.string()),
+})
+
+export const EmptyFileLinkValueLegacySchema = z.strictObject({
+	kind: z.literal(LinkKind.File),
+})
+
+// Media
+
+// Media link only represent the empty state as they turn into
+// file or image links when they filled.
+export const EmptyMediaLinkValueLegacySchema = z.strictObject({
+	kind: z.literal(LinkKind.Media),
+})
+
+// Document
+export const FilledDocumentLinkValueLegacySchema = z.strictObject({
+	// `kind` is not part of the filled schema... (legacy behavior)
+	// We transform it to the literal for consistency.
+	kind: z.pipe(
+		z.optional(z.literal(LinkKind.Document)),
+		z.transform(() => LinkKind.Document),
+	),
+	id: NonEmptyStringSchema,
+})
+
+export const EmptyDocumentLinkValueLegacySchema = z.strictObject({
+	kind: z.literal(LinkKind.Document),
+})
+
+// External
+export const FilledExternalLinkValueLegacySchema = z.strictObject({
+	// It's odd that `kind` is optional here... (legacy behavior)
+	// We transform it to the literal for consistency.
+	kind: z.pipe(
+		z.optional(z.literal(LinkKind.External)),
+		z.transform(() => LinkKind.External),
+	),
+	url: z.string(),
+	target: z.nullish(z.string()),
+	preview: z.nullish(
+		z.strictObject({
+			title: z.optional(z.string()),
+		}),
+	),
+})
+
+export const EmptyExternalLinkValueLegacySchema = z.strictObject({
+	kind: z.literal(LinkKind.External),
+})
+
+// Any
+export const AnyLinkLegacySchema = z.strictObject({
+	kind: z.transform(() => LinkKind.Any),
+})
+
+// All
+
+export const FilledLinkValueLegacySchema = z.union([
+	FilledImageLinkValueLegacySchema,
+	FilledFileLinkValueLegacySchema,
+	FilledDocumentLinkValueLegacySchema,
+	FilledExternalLinkValueLegacySchema,
+])
+
+export type FilledLinkValueLegacy = z.infer<typeof FilledLinkValueLegacySchema>
+
+const EmptyLinkValueLegacySchema = z.union([
+	EmptyImageLinkValueLegacySchema,
+	EmptyFileLinkValueLegacySchema,
+	EmptyMediaLinkValueLegacySchema,
+	EmptyDocumentLinkValueLegacySchema,
+	EmptyExternalLinkValueLegacySchema,
+	AnyLinkLegacySchema,
+])
+
+export type EmptyLinkValueLegacy = z.infer<typeof EmptyLinkValueLegacySchema>
+
+const LinkValueLegacySchema = z.union([FilledLinkValueLegacySchema, EmptyLinkValueLegacySchema])
+
+export type LinkValueLegacy = z.infer<typeof LinkValueLegacySchema>
+
+// We cannot use z.extend here because we're working with unions.
+// z.intersection wouldn't work also for the same reason.
+export const LinkLegacySchema = z.pipe(
+	z.pipe(
+		z.pipe(
+			z.record(z.string(), z.unknown()),
+			z.transform(
+				({
+					key,
+					text,
+					variant,
+					...value
+				}): {
+					key?: unknown
+					text?: unknown
+					variant?: unknown
+					value: Record<string, unknown>
+				} => ({ key, text, variant, value }),
+			),
+		),
+		z.object({
+			key: z.optional(z.string()),
+			text: z.optional(z.string()),
+			variant: z.optional(z.string()),
+			value: LinkValueLegacySchema,
+		}),
+	),
+	z.transform(({ key, text, variant, value }) => ({
+		key: z.uuidv4().safeParse(key).data ?? crypto.randomUUID(),
+		...(text ? { text } : {}),
+		...(variant ? { variant } : {}),
+		...value,
+	})),
+)
+
+export type LinkLegacy = z.infer<typeof LinkLegacySchema>

package/src/content/legacy/nestable.ts

@@ -0,0 +1,31 @@
+import { z } from "zod/mini"
+
+import { BooleanLegacySchema } from "./boolean"
+import { EmbedLegacyLooseSchema } from "./embed"
+import { EmptyLegacySchema } from "./empty"
+import { StringLegacySchema } from "./field"
+import { GeoPointLegacySchema } from "./geopoint"
+import { ImageLegacySchema } from "./image"
+import { IntegrationFieldLegacySchema } from "./integrationField"
+import { LinkLegacySchema } from "./link"
+import { RepeatableLegacySchema } from "./repeatable"
+import { RichTextLegacySchema } from "./richText"
+import { SeparatorLegacySchema } from "./separator"
+import { TableLegacySchema } from "./table"
+
+export const NestableLegacySchema = z.union([
+	EmptyLegacySchema,
+	BooleanLegacySchema,
+	EmbedLegacyLooseSchema,
+	StringLegacySchema,
+	GeoPointLegacySchema,
+	ImageLegacySchema,
+	IntegrationFieldLegacySchema,
+	LinkLegacySchema,
+	RepeatableLegacySchema,
+	RichTextLegacySchema,
+	SeparatorLegacySchema,
+	TableLegacySchema,
+])
+
+export type NestableLegacy = z.infer<typeof NestableLegacySchema>

package/src/content/legacy/repeatable.ts

@@ -0,0 +1,20 @@
+import { z } from "zod/mini"
+
+import { LinkLegacySchema } from "./link"
+
+const RepeatableLinkLegacySchema = z.pipe(
+	z.array(z.unknown()),
+	z.transform((value) =>
+		value.flatMap((item) => {
+			try {
+				return [LinkLegacySchema.parse(item)]
+			} catch {
+				return []
+			}
+		}),
+	),
+)
+
+export const RepeatableLegacySchema = RepeatableLinkLegacySchema
+
+export type RepeatableLegacy = z.infer<typeof RepeatableLegacySchema>

package/src/content/legacy/richText.ts

@@ -0,0 +1,165 @@
+import { z } from "zod/mini"
+
+// It's important to only import the types here to
+// avoid runtime circular dependencies!
+import type { EmbedContentSchema } from "../embed"
+import type { ImageViewContentSchema } from "../image"
+import type { FilledLinkValueContentSchema } from "../link"
+import { EmbedLegacyLooseSchema } from "./embed"
+import { ImageViewLegacySchema } from "./image"
+import { FilledLinkValueLegacySchema } from "./link"
+
+export const RichTextNodeType = {
+	paragraph: "paragraph",
+	heading1: "heading1",
+	heading2: "heading2",
+	heading3: "heading3",
+	heading4: "heading4",
+	heading5: "heading5",
+	heading6: "heading6",
+	preformatted: "preformatted",
+	oListItem: "o-list-item",
+	listItem: "list-item",
+	image: "image",
+	embed: "embed",
+	hyperlink: "hyperlink",
+	strong: "strong",
+	em: "em",
+} as const
+
+// Spans
+const getHyperlinkSpanSchema = <
+	TData extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+>(
+	data: TData,
+) =>
+	z.object({
+		type: z.literal(RichTextNodeType.hyperlink),
+		start: z.number(),
+		end: z.number(),
+		data,
+	})
+
+const LabelSpanSchema = z.object({
+	type: z.literal("label"),
+	start: z.number(),
+	end: z.number(),
+	data: z.pipe(
+		z.unknown(),
+		z.transform((value) => (typeof value === "string" && value.length > 0 ? value : "")),
+	),
+})
+
+const BasicSpanSchema = z.object({
+	type: z.union([
+		z.literal(RichTextNodeType.strong),
+		z.literal(RichTextNodeType.em),
+		z.literal("list-item"), // legacy case
+	]),
+	start: z.number(),
+	end: z.number(),
+})
+
+const getSpanSchema = <
+	TLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+>(
+	linkSchema: TLinkSchema,
+) => z.union([getHyperlinkSpanSchema(linkSchema), LabelSpanSchema, BasicSpanSchema])
+
+// Text blocks
+const TextBlockTypeSchema = z.union([
+	z.literal(RichTextNodeType.paragraph),
+	z.literal(RichTextNodeType.heading1),
+	z.literal(RichTextNodeType.heading2),
+	z.literal(RichTextNodeType.heading3),
+	z.literal(RichTextNodeType.heading4),
+	z.literal(RichTextNodeType.heading5),
+	z.literal(RichTextNodeType.heading6),
+	z.literal(RichTextNodeType.preformatted),
+	z.literal(RichTextNodeType.oListItem),
+	z.literal(RichTextNodeType.listItem),
+])
+
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getTextBlockSchema = <
+	TLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+>(
+	linkSchema: TLinkSchema,
+) =>
+	z.object({
+		type: TextBlockTypeSchema,
+		content: z.object({
+			text: z.string(),
+			spans: z.optional(
+				z.pipe(
+					z.array(z.unknown()),
+					z.transform((spans) => {
+						const spanSchema = getSpanSchema(linkSchema)
+
+						// Filter out invalid spans and order them by start position
+						return spans
+							.flatMap((maybeSpan) => {
+								const parsed = spanSchema.safeParse(maybeSpan)
+								return parsed.success ? [parsed.data] : []
+							})
+							.sort((a, b) => a.start - b.start)
+					}),
+				),
+			),
+		}),
+		label: z.optional(z.string()),
+		direction: z.optional(z.string()),
+	})
+
+const TextBlockLegacySchema = getTextBlockSchema(FilledLinkValueLegacySchema)
+
+// Image block
+
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getImageBlockSchema = <
+	TData extends typeof ImageViewLegacySchema | typeof ImageViewContentSchema,
+	TLinkTo extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+>(
+	data: TData,
+	linkTo: TLinkTo,
+) =>
+	z.object({
+		type: z.literal(RichTextNodeType.image),
+		data: z.extend(data, { linkTo: z.nullish(linkTo) }),
+		label: z.nullish(z.string()),
+		direction: z.nullish(z.string()),
+	})
+
+const ImageBlockLegacySchema = getImageBlockSchema(
+	ImageViewLegacySchema,
+	FilledLinkValueLegacySchema,
+)
+
+// Embed block
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getEmbedBlockSchema = <
+	TData extends typeof EmbedLegacyLooseSchema | typeof EmbedContentSchema,
+>(
+	data: TData,
+) =>
+	z.object({
+		type: z.literal(RichTextNodeType.embed),
+		data,
+		label: z.nullish(z.string()),
+		direction: z.nullish(z.string()),
+	})
+
+const EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)
+
+// Blocks
+export const BlockLegacySchema = z.union([
+	TextBlockLegacySchema,
+	ImageBlockLegacySchema,
+	EmbedBlockLegacySchema,
+])
+
+export type BlockLegacy = z.infer<typeof BlockLegacySchema>
+
+export const RichTextLegacySchema = z.array(BlockLegacySchema)
+
+export type RichTextLegacy = z.infer<typeof RichTextLegacySchema>

package/src/content/legacy/separator.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/mini"
+
+// v3 SeparatorLegacy decode accepts any input and normalizes to SeparatorContent.
+export const SeparatorLegacySchema = z.unknown()
+
+export type SeparatorLegacy = z.infer<typeof SeparatorLegacySchema>

package/src/content/legacy/slice.ts

@@ -0,0 +1,37 @@
+import { z } from "zod/mini"
+
+import { GroupItemLegacySchema, NestableAndGroupLegacySchema } from "./group"
+import { NestableLegacySchema } from "./nestable"
+
+// Simple (before 2020)
+export const SimpleSliceLegacySchema = NestableAndGroupLegacySchema
+
+export type SimpleSliceLegacy = z.infer<typeof SimpleSliceLegacySchema>
+
+// Composite (2020 to 2021)
+export const CompositeSliceLegacySchema = z.object({
+	"non-repeat": z.optional(z.record(z.string(), NestableLegacySchema)),
+	repeat: z.optional(z.array(GroupItemLegacySchema)),
+})
+
+export type CompositeSliceLegacy = z.infer<typeof CompositeSliceLegacySchema>
+
+// Shared (2021 to present)
+export const SharedSliceLegacySchema = z.object({
+	variation: z.string(),
+	primary: z.transform(
+		(value) => z.record(z.string(), NestableAndGroupLegacySchema).safeParse(value).data || {},
+	),
+	items: z.transform((value) => z.array(GroupItemLegacySchema).safeParse(value).data || []),
+})
+
+export type SharedSliceLegacy = z.infer<typeof SharedSliceLegacySchema>
+
+// All
+export const SliceLegacySchema = z.union([
+	SimpleSliceLegacySchema,
+	CompositeSliceLegacySchema,
+	SharedSliceLegacySchema,
+])
+
+export type SliceLegacy = z.infer<typeof SliceLegacySchema>

package/src/content/legacy/slices.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/mini"
+
+import { SliceLegacySchema } from "./slice"
+
+// Item
+export const SliceItemLegacySchema = z.object({
+	key: z.string(),
+	label: z.nullish(z.string()),
+	value: SliceLegacySchema,
+})
+
+export type SliceItemLegacy = z.infer<typeof SliceItemLegacySchema>
+
+// Slices
+export const SlicesLegacySchema = z.array(SliceItemLegacySchema)
+
+export type SlicesLegacy = z.infer<typeof SlicesLegacySchema>

package/src/content/legacy/table.ts

@@ -0,0 +1,39 @@
+import { z } from "zod/mini"
+
+// It's important to only import the types here to
+// avoid runtime circular dependencies!
+import type { RichTextContentSchema } from "../richText"
+import { RichTextLegacySchema } from "./richText"
+
+// Cell
+const getTableCellSchema = <
+	TContent extends typeof RichTextLegacySchema | typeof RichTextContentSchema,
+>(
+	content: TContent,
+) =>
+	z.object({
+		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+		type: z.union([z.literal("tableHeader"), z.literal("tableCell")]),
+		content,
+		columnWidth: z.optional(z.number()),
+	})
+
+// Row
+// oxlint-disable-next-line explicit-module-boundary-types
+export const getTableRowSchema = <
+	TRichText extends typeof RichTextLegacySchema | typeof RichTextContentSchema,
+>(
+	richTextSchema: TRichText,
+) =>
+	z.strictObject({
+		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+		type: z.literal("tableRow"),
+		content: z.array(getTableCellSchema(richTextSchema)),
+	})
+
+// Table
+export const TableLegacySchema = z.strictObject({
+	content: z.array(getTableRowSchema(RichTextLegacySchema)),
+})
+
+export type TableLegacy = z.infer<typeof TableLegacySchema>

package/src/content/legacy/uid.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/mini"
+
+// TODO: Can't we add business logic UID shape validation here? (not uniqueness but format)
+export const UIDLegacySchema = z.string()
+
+export type UIDLegacy = z.infer<typeof UIDLegacySchema>

package/src/content/legacy/widget.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+import { GroupLegacySchema } from "./group"
+import { NestableLegacySchema } from "./nestable"
+import { SlicesLegacySchema } from "./slices"
+import { UIDLegacySchema } from "./uid"
+
+export const WidgetLegacySchema = z.union([
+	UIDLegacySchema,
+	GroupLegacySchema,
+	SlicesLegacySchema,
+	NestableLegacySchema,
+])
+
+export type WidgetLegacy = z.infer<typeof WidgetLegacySchema>