@prismicio/types-internal 4.0.0 → 4.1.0-canary.18ae460

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.strictObject({
 	// `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.strictObject({
 	// `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.strictObject({
 	// `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.strictObject({
 	// 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,
 ) =>
@@ -81,14 +83,14 @@ const BasicSpanSchema: z.ZodMiniType<BasicSpan> = z.object({
 	end: z.number(),
 })
 
-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])
@@ -109,7 +111,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 +140,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 +148,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 +162,8 @@ export const getImageBlockSchema = <
 	})
 
 const ImageBlockLegacySchema = getImageBlockSchema(
-	ImageViewLegacySchema,
-	FilledLinkValueLegacySchema,
+	ImageLegacyViewSchema,
+	FilledLinkLegacyValueSchema,
 )
 
 type ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>

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"
@@ -22,7 +21,6 @@ import {
 	FieldContentType,
 	NumberContentSchema,
 	RangeContentSchema,
-	SelectContentDefaultValue,
 	SelectContentSchema,
 	TextContentSchema,
 	TimestampContentSchema,
@@ -107,20 +105,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
-	}
-}

package/src/content/richText.ts

@@ -1,7 +1,7 @@
 import { z } from "zod/mini"
 
 import { EmbedContentSchema } from "./embed"
-import { ImageViewContentSchema } from "./image"
+import { ImageContentViewSchema } from "./image"
 import {
 	getEmbedBlockSchema,
 	getImageBlockSchema,
@@ -9,37 +9,43 @@ import {
 	getTextBlockSchema,
 } from "./legacy/richText"
 import type { Span } from "./legacy/richText"
-import type { FilledLinkValueContent } from "./link"
-import { FilledLinkValueContentSchema } from "./link"
+import type { FilledLinkContentValue } from "./link"
+import { FilledLinkContentValueSchema } from "./link"
+
+export { RichTextNodeType } from "./legacy/richText"
+export type { RichTextNodeTypes } from "./legacy/richText"
 
 // Spans
-export type RichTextContentSpan = Span<FilledLinkValueContent>
+export type RichTextContentSpan = Span<FilledLinkContentValue>
 
 export const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> = getSpanSchema(
-	FilledLinkValueContentSchema,
+	FilledLinkContentValueSchema,
 )
 
 // Blocks
-const TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema)
-type TextBlockValue = z.infer<typeof TextBlockValueSchema>
+const RichTextContentTextBlockSchema = getTextBlockSchema(FilledLinkContentValueSchema)
+export type RichTextContentTextBlock = z.infer<typeof RichTextContentTextBlockSchema>
 
-const ImageBlockValueSchema = getImageBlockSchema(
-	ImageViewContentSchema,
-	FilledLinkValueContentSchema,
+const RichTextContentImageBlockSchema = getImageBlockSchema(
+	ImageContentViewSchema,
+	FilledLinkContentValueSchema,
 )
-type ImageBlockValue = z.infer<typeof ImageBlockValueSchema>
+export type RichTextContentImageBlock = z.infer<typeof RichTextContentImageBlockSchema>
 
-const EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema)
-type EmbedBlockValue = z.infer<typeof EmbedBlockValueSchema>
+const RichTextContentEmbedBlockSchema = getEmbedBlockSchema(EmbedContentSchema)
+export type RichTextContentEmbedBlock = z.infer<typeof RichTextContentEmbedBlockSchema>
 
 export const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([
-	TextBlockValueSchema,
-	ImageBlockValueSchema,
-	EmbedBlockValueSchema,
+	RichTextContentTextBlockSchema,
+	RichTextContentImageBlockSchema,
+	RichTextContentEmbedBlockSchema,
 ])
 
 // Used by content/codec/richText
-export type RichTextContentBlock = TextBlockValue | ImageBlockValue | EmbedBlockValue
+export type RichTextContentBlock =
+	| RichTextContentTextBlock
+	| RichTextContentImageBlock
+	| RichTextContentEmbedBlock
 
 export const RichTextContentType = "StructuredTextContent" as const