@prismicio/types-internal 4.0.0 → 4.1.0-canary.51f7473

package/src/content/legacy/link.ts

@@ -21,7 +21,7 @@ export const LinkType = {
 } as const
 
 // Image
-export const FilledImageLinkValueLegacySchema = z.strictObject({
+export const FilledImageLinkLegacyValueSchema = z.object({
 	// `kind` was normalized to the literal (legacy behavior)
 	kind: z.pipe(
 		z.string(),
@@ -36,12 +36,12 @@ export const FilledImageLinkValueLegacySchema = z.strictObject({
 	date: z.nullish(z.string()),
 })
 
-export const EmptyImageLinkValueLegacySchema = z.strictObject({
+export const EmptyImageLinkLegacyValueSchema = z.strictObject({
 	kind: z.literal(LinkKind.Image),
 })
 
 // File
-export const FilledFileLinkValueLegacySchema = z.strictObject({
+export const FilledFileLinkLegacyValueSchema = z.object({
 	// `kind` was normalized to the literal (legacy behavior)
 	kind: z.pipe(
 		z.string(),
@@ -54,7 +54,7 @@ export const FilledFileLinkValueLegacySchema = z.strictObject({
 	date: z.nullish(z.string()),
 })
 
-export const EmptyFileLinkValueLegacySchema = z.strictObject({
+export const EmptyFileLinkLegacyValueSchema = z.strictObject({
 	kind: z.literal(LinkKind.File),
 })
 
@@ -62,12 +62,12 @@ export const EmptyFileLinkValueLegacySchema = z.strictObject({
 
 // Media link only represent the empty state as they turn into
 // file or image links when they filled.
-export const EmptyMediaLinkValueLegacySchema = z.strictObject({
+export const EmptyMediaLinkLegacyValueSchema = z.strictObject({
 	kind: z.literal(LinkKind.Media),
 })
 
 // Document
-export const FilledDocumentLinkValueLegacySchema = z.strictObject({
+export const FilledDocumentLinkLegacyValueSchema = z.object({
 	// `kind` is not part of the filled schema... (legacy behavior)
 	// We transform it to the literal for consistency.
 	kind: z.pipe(
@@ -77,12 +77,12 @@ export const FilledDocumentLinkValueLegacySchema = z.strictObject({
 	id: NonEmptyStringSchema,
 })
 
-export const EmptyDocumentLinkValueLegacySchema = z.strictObject({
+export const EmptyDocumentLinkLegacyValueSchema = z.strictObject({
 	kind: z.literal(LinkKind.Document),
 })
 
 // External
-export const FilledExternalLinkValueLegacySchema = z.strictObject({
+export const FilledExternalLinkLegacyValueSchema = z.object({
 	// It's odd that `kind` is optional here... (legacy behavior)
 	// We transform it to the literal for consistency.
 	kind: z.pipe(
@@ -98,7 +98,7 @@ export const FilledExternalLinkValueLegacySchema = z.strictObject({
 	),
 })
 
-export const EmptyExternalLinkValueLegacySchema = z.strictObject({
+export const EmptyExternalLinkLegacyValueSchema = z.strictObject({
 	kind: z.literal(LinkKind.External),
 })
 
@@ -109,52 +109,52 @@ export const AnyLinkLegacySchema = z.strictObject({
 
 // All
 
-export const FilledLinkValueLegacySchema: z.ZodMiniType<FilledLinkValueLegacy> = z.union([
-	FilledImageLinkValueLegacySchema,
-	FilledFileLinkValueLegacySchema,
-	FilledDocumentLinkValueLegacySchema,
-	FilledExternalLinkValueLegacySchema,
+export const FilledLinkLegacyValueSchema: z.ZodMiniType<FilledLinkLegacyValue> = z.union([
+	FilledImageLinkLegacyValueSchema,
+	FilledFileLinkLegacyValueSchema,
+	FilledDocumentLinkLegacyValueSchema,
+	FilledExternalLinkLegacyValueSchema,
 ])
 
-type FilledImageLinkValueLegacy = z.infer<typeof FilledImageLinkValueLegacySchema>
-type FilledFileLinkValueLegacy = z.infer<typeof FilledFileLinkValueLegacySchema>
-type FilledDocumentLinkValueLegacy = z.infer<typeof FilledDocumentLinkValueLegacySchema>
-type FilledExternalLinkValueLegacy = z.infer<typeof FilledExternalLinkValueLegacySchema>
-export type FilledLinkValueLegacy =
-	| FilledImageLinkValueLegacy
-	| FilledFileLinkValueLegacy
-	| FilledDocumentLinkValueLegacy
-	| FilledExternalLinkValueLegacy
-
-const EmptyLinkValueLegacySchema: z.ZodMiniType<EmptyLinkValueLegacy> = z.union([
-	EmptyImageLinkValueLegacySchema,
-	EmptyFileLinkValueLegacySchema,
-	EmptyMediaLinkValueLegacySchema,
-	EmptyDocumentLinkValueLegacySchema,
-	EmptyExternalLinkValueLegacySchema,
+type FilledImageLinkLegacyValue = z.infer<typeof FilledImageLinkLegacyValueSchema>
+type FilledFileLinkLegacyValue = z.infer<typeof FilledFileLinkLegacyValueSchema>
+type FilledDocumentLinkLegacyValue = z.infer<typeof FilledDocumentLinkLegacyValueSchema>
+type FilledExternalLinkLegacyValue = z.infer<typeof FilledExternalLinkLegacyValueSchema>
+export type FilledLinkLegacyValue =
+	| FilledImageLinkLegacyValue
+	| FilledFileLinkLegacyValue
+	| FilledDocumentLinkLegacyValue
+	| FilledExternalLinkLegacyValue
+
+const EmptyLinkLegacyValueSchema: z.ZodMiniType<EmptyLinkLegacyValue> = z.union([
+	EmptyImageLinkLegacyValueSchema,
+	EmptyFileLinkLegacyValueSchema,
+	EmptyMediaLinkLegacyValueSchema,
+	EmptyDocumentLinkLegacyValueSchema,
+	EmptyExternalLinkLegacyValueSchema,
 	AnyLinkLegacySchema,
 ])
 
-type EmptyImageLinkValueLegacy = z.infer<typeof EmptyImageLinkValueLegacySchema>
-type EmptyFileLinkValueLegacy = z.infer<typeof EmptyFileLinkValueLegacySchema>
-type EmptyMediaLinkValueLegacy = z.infer<typeof EmptyMediaLinkValueLegacySchema>
-type EmptyDocumentLinkValueLegacy = z.infer<typeof EmptyDocumentLinkValueLegacySchema>
-type EmptyExternalLinkValueLegacy = z.infer<typeof EmptyExternalLinkValueLegacySchema>
+type EmptyImageLinkLegacyValue = z.infer<typeof EmptyImageLinkLegacyValueSchema>
+type EmptyFileLinkLegacyValue = z.infer<typeof EmptyFileLinkLegacyValueSchema>
+type EmptyMediaLinkLegacyValue = z.infer<typeof EmptyMediaLinkLegacyValueSchema>
+type EmptyDocumentLinkLegacyValue = z.infer<typeof EmptyDocumentLinkLegacyValueSchema>
+type EmptyExternalLinkLegacyValue = z.infer<typeof EmptyExternalLinkLegacyValueSchema>
 type AnyLinkLegacy = z.infer<typeof AnyLinkLegacySchema>
-export type EmptyLinkValueLegacy =
-	| EmptyImageLinkValueLegacy
-	| EmptyFileLinkValueLegacy
-	| EmptyMediaLinkValueLegacy
-	| EmptyDocumentLinkValueLegacy
-	| EmptyExternalLinkValueLegacy
+export type EmptyLinkLegacyValue =
+	| EmptyImageLinkLegacyValue
+	| EmptyFileLinkLegacyValue
+	| EmptyMediaLinkLegacyValue
+	| EmptyDocumentLinkLegacyValue
+	| EmptyExternalLinkLegacyValue
 	| AnyLinkLegacy
 
-const LinkValueLegacySchema: z.ZodMiniType<LinkValueLegacy> = z.union([
-	FilledLinkValueLegacySchema,
-	EmptyLinkValueLegacySchema,
+const LinkLegacyValueSchema: z.ZodMiniType<LinkLegacyValue> = z.union([
+	FilledLinkLegacyValueSchema,
+	EmptyLinkLegacyValueSchema,
 ])
 
-export type LinkValueLegacy = FilledLinkValueLegacy | EmptyLinkValueLegacy
+export type LinkLegacyValue = FilledLinkLegacyValue | EmptyLinkLegacyValue
 
 // We cannot use z.extend here because we're working with unions.
 // z.intersection wouldn't work also for the same reason.
@@ -180,7 +180,7 @@ export const LinkLegacySchema = z.pipe(
 			key: z.optional(z.string()),
 			text: z.optional(z.string()),
 			variant: z.optional(z.string()),
-			value: LinkValueLegacySchema as z.ZodMiniType<LinkValueLegacy, Record<string, unknown>>,
+			value: LinkLegacyValueSchema as z.ZodMiniType<LinkLegacyValue, Record<string, unknown>>,
 		}),
 	),
 	z.transform(({ key, text, variant, value }) => ({

package/src/content/legacy/richText.ts

@@ -3,21 +3,21 @@ 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 { FilledLinkValueContent, FilledLinkValueContentSchema } from "../link"
+import type { ImageContentViewSchema } from "../image"
+import type { FilledLinkContentValue, FilledLinkContentValueSchema } from "../link"
 import { EmbedLegacyLooseSchema } from "./embed"
-import { ImageViewLegacySchema } from "./image"
-import { FilledLinkValueLegacySchema } from "./link"
-import type { FilledLinkValueLegacy } from "./link"
+import { ImageLegacyViewSchema } from "./image"
+import { FilledLinkLegacyValueSchema } from "./link"
+import type { FilledLinkLegacyValue } from "./link"
 
 export const RichTextNodeType = {
-	paragraph: "paragraph",
 	heading1: "heading1",
 	heading2: "heading2",
 	heading3: "heading3",
 	heading4: "heading4",
 	heading5: "heading5",
 	heading6: "heading6",
+	paragraph: "paragraph",
 	preformatted: "preformatted",
 	oListItem: "o-list-item",
 	listItem: "list-item",
@@ -28,8 +28,10 @@ export const RichTextNodeType = {
 	em: "em",
 } as const
 
+export type RichTextNodeTypes = (typeof RichTextNodeType)[keyof typeof RichTextNodeType]
+
 // Spans
-type HyperlinkSpan<TData extends FilledLinkValueLegacy | FilledLinkValueContent> = {
+type HyperlinkSpan<TData extends FilledLinkLegacyValue | FilledLinkContentValue> = {
 	type: typeof RichTextNodeType.hyperlink
 	start: number
 	end: number
@@ -37,7 +39,7 @@ type HyperlinkSpan<TData extends FilledLinkValueLegacy | FilledLinkValueContent>
 }
 
 const getHyperlinkSpanSchema = <
-	TData extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+	TData extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
 >(
 	data: TData,
 ) =>
@@ -48,14 +50,7 @@ const getHyperlinkSpanSchema = <
 		data,
 	})
 
-type LabelSpan = {
-	type: "label"
-	start: number
-	end: number
-	data: string
-}
-
-const LabelSpanSchema: z.ZodMiniType<LabelSpan> = z.object({
+const LabelSpanSchema = z.object({
 	type: z.literal("label"),
 	start: z.number(),
 	end: z.number(),
@@ -64,14 +59,9 @@ const LabelSpanSchema: z.ZodMiniType<LabelSpan> = z.object({
 		z.transform((value) => (typeof value === "string" && value.length > 0 ? value : "")),
 	),
 })
+type LabelSpan = z.infer<typeof LabelSpanSchema>
 
-type BasicSpan = {
-	type: typeof RichTextNodeType.strong | typeof RichTextNodeType.em | "list-item"
-	start: number
-	end: number
-}
-
-const BasicSpanSchema: z.ZodMiniType<BasicSpan> = z.object({
+const BasicSpanSchema = z.object({
 	type: z.union([
 		z.literal(RichTextNodeType.strong),
 		z.literal(RichTextNodeType.em),
@@ -80,18 +70,24 @@ const BasicSpanSchema: z.ZodMiniType<BasicSpan> = z.object({
 	start: z.number(),
 	end: z.number(),
 })
+type BasicSpan = z.infer<typeof BasicSpanSchema>
 
-export type Span<TLink extends FilledLinkValueLegacy | FilledLinkValueContent> =
+export type Span<TLink extends FilledLinkLegacyValue | FilledLinkContentValue> =
 	| HyperlinkSpan<TLink>
 	| LabelSpan
 	| BasicSpan
 
 // oxlint-disable-next-line explicit-module-boundary-types
 export const getSpanSchema = <
-	TLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+	TLinkSchema extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
 >(
 	linkSchema: TLinkSchema,
-) => z.union([getHyperlinkSpanSchema(linkSchema), LabelSpanSchema, BasicSpanSchema])
+) =>
+	z.discriminatedUnion("type", [
+		getHyperlinkSpanSchema(linkSchema),
+		LabelSpanSchema,
+		BasicSpanSchema,
+	])
 
 // Text blocks
 const TextBlockTypeSchema = z.union([
@@ -109,7 +105,7 @@ const TextBlockTypeSchema = z.union([
 
 // oxlint-disable-next-line explicit-module-boundary-types
 export const getTextBlockSchema = <
-	TLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+	TLinkSchema extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
 >(
 	linkSchema: TLinkSchema,
 ) =>
@@ -138,7 +134,7 @@ export const getTextBlockSchema = <
 		direction: z.optional(z.string()),
 	})
 
-const TextBlockLegacySchema = getTextBlockSchema(FilledLinkValueLegacySchema)
+const TextBlockLegacySchema = getTextBlockSchema(FilledLinkLegacyValueSchema)
 
 type TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>
 
@@ -146,8 +142,8 @@ type TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>
 
 // oxlint-disable-next-line explicit-module-boundary-types
 export const getImageBlockSchema = <
-	TData extends typeof ImageViewLegacySchema | typeof ImageViewContentSchema,
-	TLinkTo extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
+	TData extends typeof ImageLegacyViewSchema | typeof ImageContentViewSchema,
+	TLinkTo extends typeof FilledLinkLegacyValueSchema | typeof FilledLinkContentValueSchema,
 >(
 	data: TData,
 	linkTo: TLinkTo,
@@ -160,8 +156,8 @@ export const getImageBlockSchema = <
 	})
 
 const ImageBlockLegacySchema = getImageBlockSchema(
-	ImageViewLegacySchema,
-	FilledLinkValueLegacySchema,
+	ImageLegacyViewSchema,
+	FilledLinkLegacyValueSchema,
 )
 
 type ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>
@@ -185,11 +181,10 @@ const EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)
 type EmbedBlockLegacy = z.infer<typeof EmbedBlockLegacySchema>
 
 // Blocks
-export const RichTextLegacyBlockSchema: z.ZodMiniType<RichTextLegacyBlock> = z.union([
-	TextBlockLegacySchema,
-	ImageBlockLegacySchema,
-	EmbedBlockLegacySchema,
-])
+export const RichTextLegacyBlockSchema: z.ZodMiniType<RichTextLegacyBlock> = z.discriminatedUnion(
+	"type",
+	[TextBlockLegacySchema, ImageBlockLegacySchema, EmbedBlockLegacySchema],
+)
 
 export type RichTextLegacyBlock = TextBlockLegacy | ImageBlockLegacy | EmbedBlockLegacy
 

package/src/content/link.ts

@@ -1,154 +1,165 @@
 import { z } from "zod/mini"
 
 import {
-	EmptyDocumentLinkValueLegacySchema,
-	EmptyImageLinkValueLegacySchema,
-	FilledDocumentLinkValueLegacySchema,
-	FilledFileLinkValueLegacySchema,
-	FilledImageLinkValueLegacySchema,
-	EmptyMediaLinkValueLegacySchema,
-	FilledExternalLinkValueLegacySchema,
-	EmptyExternalLinkValueLegacySchema,
+	EmptyDocumentLinkLegacyValueSchema,
+	EmptyImageLinkLegacyValueSchema,
+	FilledDocumentLinkLegacyValueSchema,
+	FilledFileLinkLegacyValueSchema,
+	FilledImageLinkLegacyValueSchema,
+	EmptyMediaLinkLegacyValueSchema,
+	FilledExternalLinkLegacyValueSchema,
+	EmptyExternalLinkLegacyValueSchema,
 	AnyLinkLegacySchema,
 	LinkType,
-	EmptyFileLinkValueLegacySchema,
+	EmptyFileLinkLegacyValueSchema,
 } from "./legacy/link"
 
 // Image
-const FilledImageLinkValueContentSchema = z.extend(FilledImageLinkValueLegacySchema, {
+const FilledImageLinkContentValueSchema = z.extend(FilledImageLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.Image),
 })
 
-const EmptyImageLinkValueContentSchema = z.extend(EmptyImageLinkValueLegacySchema, {
+const EmptyImageLinkContentValueSchema = z.extend(EmptyImageLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.Image),
 })
 
 // File
-const FilledFileLinkValueContentSchema = z.extend(FilledFileLinkValueLegacySchema, {
+const FilledFileLinkContentValueSchema = z.extend(FilledFileLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.File),
 })
 
-const EmptyFileLinkValueContentSchema = z.extend(EmptyFileLinkValueLegacySchema, {
+const EmptyFileLinkContentValueSchema = z.extend(EmptyFileLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.File),
 })
 
 // Media
-const EmptyMediaLinkValueContentSchema = z.extend(EmptyMediaLinkValueLegacySchema, {
+const EmptyMediaLinkContentValueSchema = z.extend(EmptyMediaLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.Media),
 })
 
 // Document
-const FilledDocumentLinkValueContentSchema = z.extend(FilledDocumentLinkValueLegacySchema, {
+const FilledDocumentLinkContentValueSchema = z.extend(FilledDocumentLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.Document),
 })
 
-const EmptyDocumentLinkValueContentSchema = z.extend(EmptyDocumentLinkValueLegacySchema, {
+const EmptyDocumentLinkContentValueSchema = z.extend(EmptyDocumentLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.Document),
 })
 
 // External
-const FilledExternalLinkValueContentSchema = z.extend(FilledExternalLinkValueLegacySchema, {
+const FilledExternalLinkContentValueSchema = z.extend(FilledExternalLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.External),
 })
 
-const EmptyExternalLinkValueContentSchema = z.extend(EmptyExternalLinkValueLegacySchema, {
+const EmptyExternalLinkContentValueSchema = z.extend(EmptyExternalLinkLegacyValueSchema, {
 	__TYPE__: z.literal(LinkType.External),
 })
 
 // Any
-const AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, {
+const AnyLinkContentValueSchema = z.extend(AnyLinkLegacySchema, {
 	__TYPE__: z.literal(LinkType.Any),
 })
 
 // All
 
 // Used by content/richText
-export const FilledLinkValueContentSchema: z.ZodMiniType<FilledLinkValueContent> = z.union([
-	FilledImageLinkValueContentSchema,
-	FilledFileLinkValueContentSchema,
-	FilledDocumentLinkValueContentSchema,
-	FilledExternalLinkValueContentSchema,
+export const FilledLinkContentValueSchema: z.ZodMiniType<FilledLinkContentValue> = z.union([
+	FilledImageLinkContentValueSchema,
+	FilledFileLinkContentValueSchema,
+	FilledDocumentLinkContentValueSchema,
+	FilledExternalLinkContentValueSchema,
 ])
 
 // Used by content/legacy/link
-type FilledImageLinkValueContent = z.infer<typeof FilledImageLinkValueContentSchema>
-type FilledFileLinkValueContent = z.infer<typeof FilledFileLinkValueContentSchema>
-type FilledDocumentLinkValueContent = z.infer<typeof FilledDocumentLinkValueContentSchema>
-type FilledExternalLinkValueContent = z.infer<typeof FilledExternalLinkValueContentSchema>
-export type FilledLinkValueContent =
-	| FilledImageLinkValueContent
-	| FilledFileLinkValueContent
-	| FilledDocumentLinkValueContent
-	| FilledExternalLinkValueContent
-
-const EmptyLinkValueContentSchema: z.ZodMiniType<EmptyLinkValueContent> = z.union([
-	EmptyImageLinkValueContentSchema,
-	EmptyFileLinkValueContentSchema,
-	EmptyMediaLinkValueContentSchema,
-	EmptyDocumentLinkValueContentSchema,
-	EmptyExternalLinkValueContentSchema,
-	AnyLinkValueContentSchema,
+type FilledImageLinkContentValue = z.infer<typeof FilledImageLinkContentValueSchema>
+type FilledFileLinkContentValue = z.infer<typeof FilledFileLinkContentValueSchema>
+type FilledDocumentLinkContentValue = z.infer<typeof FilledDocumentLinkContentValueSchema>
+type FilledExternalLinkContentValue = z.infer<typeof FilledExternalLinkContentValueSchema>
+export type FilledLinkContentValue =
+	| FilledImageLinkContentValue
+	| FilledFileLinkContentValue
+	| FilledDocumentLinkContentValue
+	| FilledExternalLinkContentValue
+
+const EmptyLinkContentValueSchema: z.ZodMiniType<EmptyLinkContentValue> = z.union([
+	EmptyImageLinkContentValueSchema,
+	EmptyFileLinkContentValueSchema,
+	EmptyMediaLinkContentValueSchema,
+	EmptyDocumentLinkContentValueSchema,
+	EmptyExternalLinkContentValueSchema,
+	AnyLinkContentValueSchema,
 ])
 
 // Used by content/codec/link
-type EmptyImageLinkValueContent = z.infer<typeof EmptyImageLinkValueContentSchema>
-type EmptyFileLinkValueContent = z.infer<typeof EmptyFileLinkValueContentSchema>
-type EmptyMediaLinkValueContent = z.infer<typeof EmptyMediaLinkValueContentSchema>
-type EmptyDocumentLinkValueContent = z.infer<typeof EmptyDocumentLinkValueContentSchema>
-type EmptyExternalLinkValueContent = z.infer<typeof EmptyExternalLinkValueContentSchema>
-type AnyLinkValueContent = z.infer<typeof AnyLinkValueContentSchema>
-export type EmptyLinkValueContent =
-	| EmptyImageLinkValueContent
-	| EmptyFileLinkValueContent
-	| EmptyMediaLinkValueContent
-	| EmptyDocumentLinkValueContent
-	| EmptyExternalLinkValueContent
-	| AnyLinkValueContent
-
-const LinkValueContentSchema: z.ZodMiniType<LinkValueContent> = z.union([
-	FilledLinkValueContentSchema,
-	EmptyLinkValueContentSchema,
+type EmptyImageLinkContentValue = z.infer<typeof EmptyImageLinkContentValueSchema>
+type EmptyFileLinkContentValue = z.infer<typeof EmptyFileLinkContentValueSchema>
+type EmptyMediaLinkContentValue = z.infer<typeof EmptyMediaLinkContentValueSchema>
+type EmptyDocumentLinkContentValue = z.infer<typeof EmptyDocumentLinkContentValueSchema>
+type EmptyExternalLinkContentValue = z.infer<typeof EmptyExternalLinkContentValueSchema>
+type AnyLinkContentValue = z.infer<typeof AnyLinkContentValueSchema>
+export type EmptyLinkContentValue =
+	| EmptyImageLinkContentValue
+	| EmptyFileLinkContentValue
+	| EmptyMediaLinkContentValue
+	| EmptyDocumentLinkContentValue
+	| EmptyExternalLinkContentValue
+	| AnyLinkContentValue
+
+const LinkContentValueSchema: z.ZodMiniType<LinkContentValue> = z.union([
+	FilledLinkContentValueSchema,
+	EmptyLinkContentValueSchema,
 ])
 
 // Used by content/codec/link
-export type LinkValueContent = FilledLinkValueContent | EmptyLinkValueContent
+export type LinkContentValue = FilledLinkContentValue | EmptyLinkContentValue
 
 // Content
 export const LinkContentType = "LinkContent" as const
 
-export const LinkContentSchema = z.object({
-	__TYPE__: z.literal(LinkContentType),
-	key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
-	// We cannot use z.extend here because we're working with unions.
-	// z.intersection wouldn't work also for the same reason.
-	value: z.pipe(
-		z.pipe(
+const getLinkContentSchema = <TValue extends LinkContentValue>(value: z.ZodMiniType<TValue>) =>
+	z.object({
+		__TYPE__: z.literal(LinkContentType),
+		key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+		// We cannot use z.extend here because we're working with unions.
+		// z.intersection wouldn't work also for the same reason.
+		value: z.pipe(
 			z.pipe(
-				z.record(z.string(), z.unknown()),
-				z.transform(
-					({
-						text,
-						variant,
-						...value
-					}): {
-						text?: unknown
-						variant?: unknown
-						value: Record<string, unknown>
-					} => ({ text, variant, value }),
+				z.pipe(
+					z.record(z.string(), z.unknown()),
+					z.transform(
+						({
+							text,
+							variant,
+							...value
+						}): {
+							text?: unknown
+							variant?: unknown
+							value: Record<string, unknown>
+						} => ({ text, variant, value }),
+					),
 				),
+				z.object({
+					text: z.optional(z.string()),
+					variant: z.optional(z.string()),
+					value: value as z.ZodMiniType<TValue, Record<string, unknown>>,
+				}),
 			),
-			z.object({
-				text: z.optional(z.string()),
-				variant: z.optional(z.string()),
-				value: LinkValueContentSchema as z.ZodMiniType<LinkValueContent, Record<string, unknown>>,
-			}),
+			z.transform(({ text, variant, value }) => ({
+				...(text ? { text } : {}),
+				...(variant ? { variant } : {}),
+				...value,
+			})),
 		),
-		z.transform(({ text, variant, value }) => ({
-			...(text ? { text } : {}),
-			...(variant ? { variant } : {}),
-			...value,
-		})),
-	),
-})
+	})
+
+export const FilledLinkContentSchema = getLinkContentSchema(FilledLinkContentValueSchema)
+
+export type FilledLinkContent = z.infer<typeof FilledLinkContentSchema>
+
+export const EmptyLinkContentSchema = getLinkContentSchema(EmptyLinkContentValueSchema)
+
+export type EmptyLinkContent = z.infer<typeof EmptyLinkContentSchema>
+
+export const LinkContentSchema = getLinkContentSchema(LinkContentValueSchema)
 
 export type LinkContent = z.infer<typeof LinkContentSchema>

package/src/content/nestable.ts

@@ -1,8 +1,7 @@
 import { z } from "zod/mini"
 
-import type { NestableModel } from "../model/nestable"
 import type { BooleanContent } from "./boolean"
-import { BooleanContentDefaultValue, BooleanContentSchema, BooleanContentType } from "./boolean"
+import { BooleanContentSchema, BooleanContentType } from "./boolean"
 import type { EmbedContent } from "./embed"
 import { EmbedContentSchema, EmbedContentType } from "./embed"
 import type { EmptyContent } from "./empty"
@@ -16,17 +15,7 @@ import type {
 	TextContent,
 	TimestampContent,
 } from "./field"
-import {
-	ColorContentSchema,
-	DateContentSchema,
-	FieldContentType,
-	NumberContentSchema,
-	RangeContentSchema,
-	SelectContentDefaultValue,
-	SelectContentSchema,
-	TextContentSchema,
-	TimestampContentSchema,
-} from "./field"
+import { FieldContentType, FieldContentSchema } from "./field"
 import type { GeoPointContent } from "./geopoint"
 import { GeoPointContentSchema, GeoPointContentType } from "./geopoint"
 import type { ImageContent } from "./image"
@@ -44,25 +33,19 @@ import { SeparatorContentSchema, SeparatorContentType } from "./separator"
 import type { TableContent } from "./table"
 import { TableContentSchema, TableContentType } from "./table"
 
-export const NestableContentSchema: z.ZodMiniType<NestableContent> = z.union([
+export const NestableContentSchema = z.discriminatedUnion("__TYPE__", [
 	EmptyContentSchema,
 	BooleanContentSchema,
-	ColorContentSchema,
-	DateContentSchema,
 	EmbedContentSchema,
 	GeoPointContentSchema,
 	ImageContentSchema,
 	IntegrationFieldContentSchema,
 	LinkContentSchema,
-	NumberContentSchema,
-	RangeContentSchema,
 	RepeatableContentSchema,
 	RichTextContentSchema,
-	SelectContentSchema,
 	SeparatorContentSchema,
 	TableContentSchema,
-	TextContentSchema,
-	TimestampContentSchema,
+	FieldContentSchema,
 ])
 
 export type NestableContent =
@@ -107,20 +90,3 @@ export function isNestableContent(content: {
 }): content is { __TYPE__: NestableContentType } {
 	return (NestableContentTypes as string[]).includes(content.__TYPE__)
 }
-
-/**
- * Returns the default value for a nestable widget based on its configuration.
- * Currently only Boolean and Select fields have default values.
- */
-export const NestableContentDefaultValue = (
-	widgetDef: NestableModel,
-): NestableContent | undefined => {
-	switch (widgetDef.type) {
-		case "Boolean":
-			return BooleanContentDefaultValue(widgetDef)
-		case "Select":
-			return SelectContentDefaultValue(widgetDef)
-		default:
-			return undefined
-	}
-}