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

package/src/content/link.ts

@@ -0,0 +1,131 @@
+import { z } from "zod/mini"
+
+import {
+	EmptyDocumentLinkValueLegacySchema,
+	EmptyImageLinkValueLegacySchema,
+	FilledDocumentLinkValueLegacySchema,
+	FilledFileLinkValueLegacySchema,
+	FilledImageLinkValueLegacySchema,
+	EmptyMediaLinkValueLegacySchema,
+	FilledExternalLinkValueLegacySchema,
+	EmptyExternalLinkValueLegacySchema,
+	AnyLinkLegacySchema,
+	LinkType,
+	EmptyFileLinkValueLegacySchema,
+} from "./legacy/link"
+
+// Image
+const FilledImageLinkValueContentSchema = z.extend(FilledImageLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Image),
+})
+
+const EmptyImageLinkValueContentSchema = z.extend(EmptyImageLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Image),
+})
+
+// File
+const FilledFileLinkValueContentSchema = z.extend(FilledFileLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.File),
+})
+
+const EmptyFileLinkValueContentSchema = z.extend(EmptyFileLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.File),
+})
+
+// Media
+const EmptyMediaLinkValueContentSchema = z.extend(EmptyMediaLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Media),
+})
+
+// Document
+const FilledDocumentLinkValueContentSchema = z.extend(FilledDocumentLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Document),
+})
+
+const EmptyDocumentLinkValueContentSchema = z.extend(EmptyDocumentLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Document),
+})
+
+// External
+const FilledExternalLinkValueContentSchema = z.extend(FilledExternalLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.External),
+})
+
+const EmptyExternalLinkValueContentSchema = z.extend(EmptyExternalLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.External),
+})
+
+// Any
+const AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, {
+	__TYPE__: z.literal(LinkType.Any),
+})
+
+// All
+
+// Used by content/richText
+export const FilledLinkValueContentSchema = z.union([
+	FilledImageLinkValueContentSchema,
+	FilledFileLinkValueContentSchema,
+	FilledDocumentLinkValueContentSchema,
+	FilledExternalLinkValueContentSchema,
+])
+
+// Used by content/legacy/link
+export type FilledLinkValueContent = z.infer<typeof FilledLinkValueContentSchema>
+
+const EmptyLinkValueContentSchema = z.union([
+	EmptyImageLinkValueContentSchema,
+	EmptyFileLinkValueContentSchema,
+	EmptyMediaLinkValueContentSchema,
+	EmptyDocumentLinkValueContentSchema,
+	EmptyExternalLinkValueContentSchema,
+	AnyLinkValueContentSchema,
+])
+
+// Used by content/codec/link
+export type EmptyLinkValueContent = z.infer<typeof EmptyLinkValueContentSchema>
+
+const LinkValueContentSchema = z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema])
+
+// Used by content/codec/link
+export type LinkValueContent = z.infer<typeof LinkValueContentSchema>
+
+// 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(
+			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: z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema]),
+			}),
+		),
+		z.transform(({ text, variant, value }) => ({
+			...(text ? { text } : {}),
+			...(variant ? { variant } : {}),
+			...value,
+		})),
+	),
+})
+
+export type LinkContent = z.infer<typeof LinkContentSchema>

package/src/content/nestable.ts

@@ -0,0 +1,64 @@
+import { z } from "zod/mini"
+
+import type { NestableModel } from "../model/nestable"
+import { BooleanContentDefaultValue, BooleanContentSchema } from "./boolean"
+import { EmbedContentSchema } from "./embed"
+import { EmptyContentSchema } from "./empty"
+import {
+	ColorContentSchema,
+	DateContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentDefaultValue,
+	SelectContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+} from "./field"
+import { GeoPointContentSchema } from "./geopoint"
+import { ImageContentSchema } from "./image"
+import { IntegrationFieldContentSchema } from "./integrationField"
+import { LinkContentSchema } from "./link"
+import { RepeatableContentSchema } from "./repeatable"
+import { RichTextContentSchema } from "./richText"
+import { SeparatorContentSchema } from "./separator"
+import { TableContentSchema } from "./table"
+
+export const NestableContentSchema = z.union([
+	EmptyContentSchema,
+	BooleanContentSchema,
+	ColorContentSchema,
+	DateContentSchema,
+	EmbedContentSchema,
+	GeoPointContentSchema,
+	ImageContentSchema,
+	IntegrationFieldContentSchema,
+	LinkContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	RepeatableContentSchema,
+	RichTextContentSchema,
+	SelectContentSchema,
+	SeparatorContentSchema,
+	TableContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+])
+
+export type NestableContent = z.infer<typeof NestableContentSchema>
+
+/**
+ * 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/repeatable.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/mini"
+
+import { LinkContentSchema } from "./link"
+
+export const RepeatableContentType = "RepeatableContent" as const
+
+export const RepeatableContentSchema = z.object({
+	__TYPE__: z.literal(RepeatableContentType),
+	type: z.literal("Link"),
+	value: z.array(LinkContentSchema),
+})
+
+export type RepeatableContent = z.infer<typeof RepeatableContentSchema>

package/src/content/richText.ts

@@ -0,0 +1,32 @@
+import { z } from "zod/mini"
+
+import { EmbedContentSchema } from "./embed"
+import { ImageViewContentSchema } from "./image"
+import { getEmbedBlockSchema, getImageBlockSchema, getTextBlockSchema } from "./legacy/richText"
+import { FilledLinkValueContentSchema } from "./link"
+
+const TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema)
+const ImageBlockValueSchema = getImageBlockSchema(
+	ImageViewContentSchema,
+	FilledLinkValueContentSchema,
+)
+const EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema)
+
+// Blocks
+const BlockValueSchema = z.union([
+	TextBlockValueSchema,
+	ImageBlockValueSchema,
+	EmbedBlockValueSchema,
+])
+
+// Used by content/richText
+export type BlockValue = z.infer<typeof BlockValueSchema>
+
+export const RichTextContentType = "StructuredTextContent" as const
+
+export const RichTextContentSchema = z.object({
+	__TYPE__: z.literal(RichTextContentType),
+	value: z.array(BlockValueSchema),
+})
+
+export type RichTextContent = z.infer<typeof RichTextContentSchema>

package/src/content/separator.ts

@@ -0,0 +1,9 @@
+import { z } from "zod/mini"
+
+export const SeparatorContentType = "SeparatorContent" as const
+
+export const SeparatorContentSchema = z.object({
+	__TYPE__: z.literal(SeparatorContentType),
+})
+
+export type SeparatorContent = z.infer<typeof SeparatorContentSchema>

package/src/content/slice.ts

@@ -0,0 +1,41 @@
+import { z } from "zod/mini"
+
+import { GroupItemContentSchema, NestableAndGroupContentSchema } from "./group"
+import { NestableContentSchema } from "./nestable"
+
+// Simple (before 2020)
+export const SimpleSliceContentSchema = NestableAndGroupContentSchema
+
+export type SimpleSliceContent = z.infer<typeof SimpleSliceContentSchema>
+
+// Composite (2020 to 2021)
+export const CompositeSliceContentType = "CompositeSliceContent" as const
+
+export const CompositeSliceContentSchema = z.object({
+	__TYPE__: z.literal(CompositeSliceContentType),
+	nonRepeat: z.record(z.string(), NestableContentSchema),
+	repeat: z.array(GroupItemContentSchema),
+})
+
+export type CompositeSliceContent = z.infer<typeof CompositeSliceContentSchema>
+
+// Shared (2021 to present)
+export const SharedSliceContentType = "SharedSliceContent" as const
+
+export const SharedSliceContentSchema = z.object({
+	__TYPE__: z.literal(SharedSliceContentType),
+	variation: z.string(),
+	primary: z.record(z.string(), NestableAndGroupContentSchema),
+	items: z.array(GroupItemContentSchema),
+})
+
+export type SharedSliceContent = z.infer<typeof SharedSliceContentSchema>
+
+// All
+export const SliceContentSchema = z.union([
+	SimpleSliceContentSchema,
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema,
+])
+
+export type SliceContent = z.infer<typeof SliceContentSchema>

package/src/content/slices.ts

@@ -0,0 +1,23 @@
+import { z } from "zod/mini"
+
+import { SliceContentSchema } from "./slice"
+
+// Item
+export const SliceItemContentSchema = z.object({
+	key: z.string(),
+	name: z.string(),
+	maybeLabel: z.optional(z.string()),
+	widget: SliceContentSchema,
+})
+
+export type SliceItemContent = z.infer<typeof SliceItemContentSchema>
+
+// Slices
+export const SlicesContentType = "SliceContentType" as const
+
+export const SlicesContentSchema = z.object({
+	__TYPE__: z.literal(SlicesContentType),
+	value: z.array(SliceItemContentSchema),
+})
+
+export type SlicesContent = z.infer<typeof SlicesContentSchema>

package/src/content/table.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/mini"
+
+import { getTableRowSchema } from "./legacy/table"
+import { RichTextContentSchema } from "./richText"
+
+export const TableContentType = "TableContent" as const
+
+// Table
+export const TableContentSchema = z.object({
+	__TYPE__: z.literal(TableContentType),
+	content: z.array(getTableRowSchema(RichTextContentSchema)),
+})
+
+export type TableContent = z.infer<typeof TableContentSchema>

package/src/content/uid.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const UIDContentType = "UIDContent" as const
+
+export const UIDContentSchema = z.object({
+	__TYPE__: z.literal(UIDContentType),
+	value: z.string(),
+})
+
+export type UIDContent = z.infer<typeof UIDContentSchema>

package/src/content/utils.ts

@@ -1,110 +1,10 @@
-import { isRight } from "fp-ts/lib/Either"
+import type { SliceItemContent } from "./slices"
+import type { WidgetContent } from "./widget"
 
-import type {
-	CompositeSlice,
-	Group,
-	NestableWidget,
-	StaticSlices,
-	UID,
-	VariationFields,
-} from "../customtypes"
-import {
-	FieldContentType,
-	FieldType,
-	SharedSliceItemContent,
-	SliceItemContent,
-	WidgetContent,
-} from "./fields"
-export { hasContentType, withKey } from "./helpers"
-import { hasContentType } from "./helpers"
-
-type WithFieldType = { __TYPE__: string; type: FieldType }
-export function hasFieldContentType(obj: unknown): obj is WithFieldType {
-	return (
-		hasContentType(obj) &&
-		obj.__TYPE__ === FieldContentType &&
-		(obj as WithFieldType)?.type !== undefined &&
-		typeof (obj as WithFieldType).type === "string" &&
-		isRight(FieldType.decode((obj as WithFieldType).type))
-	)
-}
-
-export type TraverseSliceContentFn = <
-	S extends SliceItemContent | SharedSliceItemContent,
-	D extends VariationFields | CompositeSlice | Group | NestableWidget,
->({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	model?: D | undefined
-	content: S
-}) => S | SharedSliceItemContent | undefined
-
-export type TraverseWidgetContentFn<
-	ContentTransformMode extends "preserve" | "widen" = "preserve",
-> = <
-	C extends WidgetContent,
-	D extends NestableWidget | StaticSlices | Group | UID,
->({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	model?: D | undefined
-	content: C
-}) =>
-	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
-	| undefined
-
-export type TraverseWidgetContentWithModelFn<
-	ContentTransformMode extends "preserve" | "widen" = "preserve",
-> = <
-	C extends WidgetContent | undefined,
-	D extends NestableWidget | StaticSlices | Group | UID,
->({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	model: D
-	content: C
-}) =>
-	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
-	| undefined
-
-export type TraverseSliceContentWithModelFn = <
-	S extends SliceItemContent | SharedSliceItemContent | undefined,
-	D extends VariationFields | CompositeSlice | Group | NestableWidget,
->({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	model: D
-	content: S
-}) => S | SharedSliceItemContent | undefined
+// Field content type constant
+export const FieldContentType = "FieldContent"
 
+// Content path entry types
 export type ContentPathEntry = {
 	type:
 		| "CustomType"
@@ -122,6 +22,7 @@ export type ContentPathEntry = {
 export type ContentPath = ReadonlyArray<ContentPathEntry>
 
 const PATH_SEPARATOR = "::"
+
 export const ContentPath = {
 	serialize(path: ContentPath): string {
 		return path.map((entry) => entry.key).join(PATH_SEPARATOR)
@@ -143,3 +44,34 @@ export const ContentPath = {
 		}, [])
 	},
 }
+
+// Traverse function types
+export type TraverseSliceContentFn = <S extends SliceItemContent>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model?: unknown
+	content: S
+}) => S | undefined
+
+export type TraverseWidgetContentFn<
+	ContentTransformMode extends "preserve" | "widen" = "preserve",
+> = <C extends WidgetContent>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model?: unknown
+	content: C
+}) => ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent) | undefined

package/src/content/widget.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/mini"
+
+import { GroupContentSchema } from "./group"
+import { NestableContentSchema } from "./nestable"
+import { SlicesContentSchema } from "./slices"
+import { UIDContentSchema } from "./uid"
+
+export const WidgetContentSchema = z.union([
+	GroupContentSchema,
+	NestableContentSchema,
+	UIDContentSchema,
+	SlicesContentSchema,
+])
+
+export type WidgetContent = z.infer<typeof WidgetContentSchema>
+
+export type ContentType = WidgetContent["__TYPE__"]

package/src/content/{fields/withDefaultValues.ts → withDefaultValues.ts}

@@ -1,35 +1,29 @@
-import {
-	type NestableWidget,
-	type SlicePrimaryWidget,
-	Group,
-	GroupFieldType,
-} from "../../customtypes"
-import {
-	GroupContent,
-	GroupContentDefaultValue,
-	GroupContentType,
-	groupContentWithDefaultValues,
-	isGroupContent,
-} from "./GroupContent"
-import type { NestableContent } from "./nestable"
+import type { GroupModel, NestedGroupModel } from "../model/group"
+import type { NestableModel } from "../model/nestable"
+import { GroupContentType, groupContentWithDefaultValues, GroupContentSchema } from "./group"
+import type { GroupContent } from "./group"
 import { NestableContentDefaultValue } from "./nestable"
-import type { SlicePrimaryContent } from "./slices/Slice/SlicePrimaryContent"
+import type { NestableContent } from "./nestable"
 
+/**
+ * Applies default values to slice primary content (non-repeat zone) based on the model configuration.
+ * For each widget in the customType that has no corresponding content, this will add the default value.
+ */
 export function withDefaultSlicePrimaryContentValues(
-	customType: Record<string, SlicePrimaryWidget>,
-	content: Partial<Record<string, SlicePrimaryContent>>,
-): Record<string, SlicePrimaryContent> {
-	const updatedContent = content as Record<string, SlicePrimaryContent>
+	customType: Record<string, NestableModel | NestedGroupModel>,
+	content: Partial<Record<string, NestableContent | GroupContent>>,
+): Record<string, NestableContent | GroupContent> {
+	const updatedContent = content as Record<string, NestableContent | GroupContent>
 
 	for (const [widgetKey, widgetDef] of Object.entries(customType)) {
 		const widgetContent = content[widgetKey]
 
 		if (widgetContent === undefined) {
-			if (widgetDef.type === GroupFieldType) {
-				updatedContent[widgetKey] = groupContentWithDefaultValues(
-					widgetDef,
-					GroupContentDefaultValue,
-				)
+			if (widgetDef.type === "Group") {
+				updatedContent[widgetKey] = groupContentWithDefaultValues(widgetDef, {
+					__TYPE__: GroupContentType,
+					value: [],
+				})
 			} else {
 				const defaultValue = NestableContentDefaultValue(widgetDef)
 
@@ -41,19 +35,21 @@ export function withDefaultSlicePrimaryContentValues(
 			continue
 		}
 
-		if (widgetDef.type === GroupFieldType && isGroupContent(widgetContent)) {
-			updatedContent[widgetKey] = groupContentWithDefaultValues(
-				widgetDef,
-				widgetContent,
-			)
+		const maybeGroupContent = GroupContentSchema.safeParse(widgetContent)
+		if (widgetDef.type === "Group" && maybeGroupContent.success) {
+			updatedContent[widgetKey] = groupContentWithDefaultValues(widgetDef, maybeGroupContent.data)
 		}
 	}
 
 	return updatedContent
 }
 
+/**
+ * Applies default values to nestable content based on the model configuration.
+ * For each widget in the customType that has no corresponding content, this will add the default value.
+ */
 export function withDefaultNestableContentValues(
-	customType: Record<string, NestableWidget>,
+	customType: Record<string, NestableModel>,
 	content: Record<string, NestableContent>,
 ): Record<string, NestableContent> {
 	return Object.entries(customType).reduce<Record<string, NestableContent>>(
@@ -64,7 +60,7 @@ export function withDefaultNestableContentValues(
 					? {
 							...updatedContent,
 							[widgetKey]: defaultValue,
-					  }
+						}
 					: updatedContent
 			}
 
@@ -74,17 +70,19 @@ export function withDefaultNestableContentValues(
 	)
 }
 
+/**
+ * Applies default values to repeatable content items (like group items or slice repeat zones).
+ * For each item, it ensures all required fields have values based on the model configuration.
+ */
 export function repeatableContentWithDefaultNestableContentValues<
 	T extends {
 		value: [string, GroupContent | NestableContent][]
 	},
->(fields: Record<string, Group | NestableWidget>, content: T[]): T[] {
+>(fields: Record<string, GroupModel | NestableModel>, content: T[]): T[] {
 	const groupKeys = Object.entries(fields)
 	return content.map((contentItem) => {
 		return groupKeys.reduce((updatedContentItem, [key, fieldDef]) => {
-			const maybeContentItemValue = contentItem.value.find(
-				([_key]) => _key === key,
-			)
+			const maybeContentItemValue = contentItem.value.find(([_key]) => _key === key)
 
 			if (fieldDef.type === "Group") {
 				const defaultValue = groupContentWithDefaultValues(
@@ -106,10 +104,7 @@ export function repeatableContentWithDefaultNestableContentValues<
 				const defaultValue = NestableContentDefaultValue(fieldDef)
 				return {
 					...updatedContentItem,
-					value: [
-						...updatedContentItem.value,
-						...(defaultValue ? [[key, defaultValue]] : []),
-					],
+					value: [...updatedContentItem.value, ...(defaultValue ? [[key, defaultValue]] : [])],
 				}
 			}