@prismicio/types-internal 3.17.0 → 4.0.0-canary.4689e2d

package/src/content/richText.ts

@@ -0,0 +1,60 @@
+import { z } from "zod/mini"
+
+import { EmbedContentSchema } from "./embed"
+import { ImageContentViewSchema } from "./image"
+import {
+	getEmbedBlockSchema,
+	getImageBlockSchema,
+	getSpanSchema,
+	getTextBlockSchema,
+} from "./legacy/richText"
+import type { Span } from "./legacy/richText"
+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<FilledLinkContentValue>
+
+export const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> = getSpanSchema(
+	FilledLinkContentValueSchema,
+)
+
+// Blocks
+const RichTextContentTextBlockSchema = getTextBlockSchema(FilledLinkContentValueSchema)
+export type RichTextContentTextBlock = z.infer<typeof RichTextContentTextBlockSchema>
+
+const RichTextContentImageBlockSchema = getImageBlockSchema(
+	ImageContentViewSchema,
+	FilledLinkContentValueSchema,
+)
+export type RichTextContentImageBlock = z.infer<typeof RichTextContentImageBlockSchema>
+
+const RichTextContentEmbedBlockSchema = getEmbedBlockSchema(EmbedContentSchema)
+export type RichTextContentEmbedBlock = z.infer<typeof RichTextContentEmbedBlockSchema>
+
+export const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([
+	RichTextContentTextBlockSchema,
+	RichTextContentImageBlockSchema,
+	RichTextContentEmbedBlockSchema,
+])
+
+// Used by content/codec/richText
+export type RichTextContentBlock =
+	| RichTextContentTextBlock
+	| RichTextContentImageBlock
+	| RichTextContentEmbedBlock
+
+export const RichTextContentType = "StructuredTextContent" as const
+
+export type RichTextContent = {
+	__TYPE__: typeof RichTextContentType
+	value: RichTextContentBlock[]
+}
+
+export const RichTextContentSchema: z.ZodMiniType<RichTextContent> = z.object({
+	__TYPE__: z.literal(RichTextContentType),
+	value: z.array(RichTextContentBlockSchema),
+})

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"
+
+// Legacy (before 2020)
+export const LegacySliceContentSchema = NestableAndGroupContentSchema
+
+export type LegacySliceContent = z.infer<typeof LegacySliceContentSchema>
+
+// 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.ZodMiniType<SliceContent> = z.union([
+	LegacySliceContentSchema,
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema,
+])
+
+export type SliceContent = LegacySliceContent | CompositeSliceContent | SharedSliceContent

package/src/content/slices.ts

@@ -0,0 +1,57 @@
+import { z } from "zod/mini"
+
+import {
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema,
+	LegacySliceContentSchema,
+	SliceContentSchema,
+} from "./slice"
+
+// Item
+const getSliceItemContentSchema = <
+	TWidgetSchema extends
+		| typeof LegacySliceContentSchema
+		| typeof CompositeSliceContentSchema
+		| typeof SharedSliceContentSchema
+		| typeof SliceContentSchema,
+>(
+	widgetSchema: TWidgetSchema,
+) => {
+	return z.object({
+		key: z.string(),
+		name: z.string(),
+		maybeLabel: z.optional(z.string()),
+		widget: widgetSchema,
+	})
+}
+
+export const LegacySliceItemContentSchema = getSliceItemContentSchema(LegacySliceContentSchema)
+
+export type LegacySliceItemContent = z.infer<typeof LegacySliceItemContentSchema>
+
+export const CompositeSliceItemContentSchema = getSliceItemContentSchema(
+	CompositeSliceContentSchema,
+)
+
+export type CompositeSliceItemContent = z.infer<typeof CompositeSliceItemContentSchema>
+
+export const SharedSliceItemContentSchema = getSliceItemContentSchema(SharedSliceContentSchema)
+
+export type SharedSliceItemContent = z.infer<typeof SharedSliceItemContentSchema>
+
+// All
+export const SliceItemContentSchema = getSliceItemContentSchema(SliceContentSchema)
+
+export type SliceItemContent = z.infer<typeof SliceItemContentSchema>
+
+// Slices
+
+// Typo (missing `s`) is legacy...
+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/widget.ts

@@ -0,0 +1,21 @@
+import { z } from "zod/mini"
+
+import type { GroupContent } from "./group"
+import { GroupContentSchema } from "./group"
+import type { NestableContent } from "./nestable"
+import { NestableContentSchema } from "./nestable"
+import type { SlicesContent } from "./slices"
+import { SlicesContentSchema } from "./slices"
+import type { UIDContent } from "./uid"
+import { UIDContentSchema } from "./uid"
+
+export const WidgetContentSchema: z.ZodMiniType<WidgetContent> = z.union([
+	GroupContentSchema,
+	NestableContentSchema,
+	UIDContentSchema,
+	SlicesContentSchema,
+])
+
+export type WidgetContent = GroupContent | NestableContent | UIDContent | SlicesContent
+
+export type ContentType = WidgetContent["__TYPE__"]

package/src/helpers/contentPath.ts

@@ -0,0 +1,35 @@
+export type Part = {
+	type:
+		| "CustomType"
+		| "Widget"
+		| "SharedSlice"
+		| "Slice"
+		| "LegacySlice"
+		| "GroupItem"
+		| "primary"
+		| "items"
+		| "RepeatableItem"
+	key: string
+}
+
+export type Path = ReadonlyArray<Part>
+
+const PATH_SEPARATOR = "::"
+
+export function serialize(path: Path): string {
+	return path.map((part) => part.key).join(PATH_SEPARATOR)
+}
+
+export function current(path: Path): Part | undefined {
+	return path[path.length - 1]
+}
+
+export function append(path: string, strElement: string): string {
+	return path + PATH_SEPARATOR + strElement
+}
+
+export function make(...entries: (Pick<Part, "type"> & Partial<Pick<Part, "key">>)[]): Path {
+	return entries.reduce<Path>((acc, { key, type }) => {
+		return key ? acc.concat({ key, type }) : acc
+	}, [])
+}

package/src/helpers/customTypeModel.ts

@@ -0,0 +1,113 @@
+import type { CustomTypeModel, StaticCustomTypeModel } from "../model/customType"
+import type { StaticSectionModel } from "../model/section"
+import type { SharedSliceModel, StaticSliceModel } from "../model/slice"
+
+export function toStatic(
+	customType: CustomTypeModel,
+	sharedSlices: Map<string, SharedSliceModel> | Record<string, SharedSliceModel>,
+): StaticCustomTypeModel {
+	const json: StaticCustomTypeModel["json"] = {}
+
+	const sharedSlicesMap =
+		sharedSlices instanceof Map ? sharedSlices : new Map(Object.entries(sharedSlices))
+
+	for (const [tabKey, tab] of Object.entries(customType.json)) {
+		const tabJSON: StaticCustomTypeModel["json"][string] = {}
+		for (const [key, widget] of Object.entries(tab)) {
+			switch (widget.type) {
+				case "Slices":
+				case "Choice":
+					const choices: Record<string, StaticSliceModel> = {}
+					for (const [id, model] of Object.entries(widget.config?.choices || {})) {
+						if (model.type === "SharedSlice") {
+							const sharedSlice = sharedSlicesMap.get(id)
+							if (sharedSlice) {
+								choices[id] = sharedSlice
+							}
+						} else {
+							choices[id] = model
+						}
+					}
+
+					tabJSON[key] = {
+						...widget,
+						config: { ...widget.config, choices },
+					}
+					break
+				default:
+					tabJSON[key] = widget
+			}
+		}
+
+		json[tabKey] = tabJSON
+	}
+
+	return { ...customType, json }
+}
+
+export function flatten(customType: StaticCustomTypeModel): StaticSectionModel {
+	return Object.values(customType.json).reduce((acc, fields) => ({ ...acc, ...fields }), {})
+}
+
+export function collectSharedSlices(
+	customType: StaticCustomTypeModel,
+): Record<string, SharedSliceModel> {
+	const sharedSlices: Record<string, SharedSliceModel> = {}
+
+	const flattened = flatten(customType)
+	for (const widget of Object.values(flattened)) {
+		if (widget.type === "Slices" || widget.type === "Choice") {
+			for (const [id, model] of Object.entries(widget.config?.choices || {})) {
+				if (model.type === "SharedSlice") {
+					sharedSlices[id] = model
+				}
+			}
+		}
+	}
+
+	return sharedSlices
+}
+
+export function filterMissingSharedSlices<
+	TCustomType extends StaticCustomTypeModel | CustomTypeModel,
+>(
+	customType: TCustomType,
+	sharedSlices: Map<string, SharedSliceModel> | Record<string, SharedSliceModel>,
+): TCustomType {
+	const json: TCustomType["json"] = {}
+
+	const sharedSlicesMap =
+		sharedSlices instanceof Map ? sharedSlices : new Map(Object.entries(sharedSlices))
+
+	for (const [tabKey, tab] of Object.entries(customType.json)) {
+		const tabJSON: typeof tab = {}
+		for (const [key, widget] of Object.entries(tab)) {
+			switch (widget.type) {
+				case "Slices":
+				case "Choice":
+					const choices: Required<typeof widget>["config"]["choices"] = {}
+					for (const [id, model] of Object.entries(widget.config?.choices || {})) {
+						if (model.type === "SharedSlice") {
+							if (sharedSlicesMap.get(id)) {
+								choices[id] = model
+							}
+						} else {
+							choices[id] = model
+						}
+					}
+
+					tabJSON[key] = {
+						...widget,
+						config: { ...widget.config, choices },
+					}
+					break
+				default:
+					tabJSON[key] = widget
+			}
+		}
+
+		json[tabKey] = tabJSON
+	}
+
+	return { ...customType, json }
+}

package/src/helpers/documentContent.ts

@@ -0,0 +1,108 @@
+import { z } from "zod/mini"
+
+import { DocumentLegacyCodec } from "../content/codec/document"
+import { defaultCtx } from "../content/codec/legacyContentCtx"
+import type { DocumentContent } from "../content/document"
+import type { DocumentLegacy } from "../content/legacy/document"
+import { DocumentLegacySchema } from "../content/legacy/document"
+import { isNestableContent } from "../content/nestable"
+import type { CompositeSliceItemContent, LegacySliceItemContent } from "../content/slices"
+import type { WidgetContent } from "../content/widget"
+import type { StaticCustomTypeModel } from "../model/customType"
+import type { FieldOrSliceType } from "../model/widget"
+import { FieldOrSliceTypeSchema } from "../model/widget"
+import * as contentPath from "./contentPath"
+import * as customTypeModel from "./customTypeModel"
+import * as sliceContent from "./sliceContent"
+import { traverseDocumentContent } from "./traverseContent"
+
+export function collectWidgets<TWidgetContent extends WidgetContent>(
+	document: DocumentContent,
+	test: (
+		content: WidgetContent,
+		args: {
+			path: contentPath.Path
+			key: string
+			apiID: string
+		},
+	) => content is TWidgetContent,
+): Record<string, TWidgetContent> {
+	const collected: Record<string, TWidgetContent> = {}
+
+	traverseDocumentContent(document, {
+		transformWidget: ({ content, ...args }) => {
+			if (test(content, args)) {
+				collected[contentPath.serialize(args.path)] = content
+			}
+
+			return content
+		},
+	})
+
+	return collected
+}
+
+export function fromLegacy(
+	legacy: DocumentLegacy,
+	model: StaticCustomTypeModel,
+): DocumentContent | undefined {
+	const parsed = DocumentLegacySchema.safeParse(legacy)
+	if (!parsed.success) {
+		return
+	}
+
+	const types = new Map<string, FieldOrSliceType>()
+	const keys = new Map<string, string>()
+	const widgets: DocumentLegacy = {}
+	for (const [key, value] of Object.entries(parsed.data)) {
+		if (key.endsWith("_TYPE")) {
+			const parsed = FieldOrSliceTypeSchema.safeParse(value)
+			if (parsed.success) {
+				types.set(key.substring(0, key.length - 5), parsed.data)
+			}
+		} else if (key.endsWith("_KEY")) {
+			const parsed = z.uuidv4().safeParse(value)
+			if (parsed.success) {
+				keys.set(key.substring(0, key.length - 4), parsed.data)
+			}
+		} else if (!key.endsWith("_POSITION")) {
+			widgets[key] = value
+		}
+	}
+
+	const result = DocumentLegacyCodec(defaultCtx("", types, keys)).toContent(widgets)
+	if (!result.success) {
+		return
+	}
+
+	const needsMigration = Object.values(customTypeModel.collectSharedSlices(model)).some((slice) =>
+		Boolean(slice.legacyPaths),
+	)
+
+	if (needsMigration) {
+		return traverseDocumentContent(result.data, {
+			model,
+			transformSlice: ({ content, model }) => {
+				if (model?.type === "SharedSlice") {
+					if (content.widget.__TYPE__ === "CompositeSliceContent") {
+						return sliceContent.compositeToShared(content as CompositeSliceItemContent, model)
+					} else if (
+						content.widget.__TYPE__ === "GroupContentType" ||
+						isNestableContent(content.widget)
+					) {
+						return sliceContent.legacyToShared(content as LegacySliceItemContent, model)
+					}
+				}
+				return content
+			},
+		})
+	}
+
+	return result.data
+}
+
+export function toLegacy(document: DocumentContent): DocumentLegacy {
+	const { content, types, keys } = DocumentLegacyCodec(defaultCtx("")).fromContent(document)
+
+	return { ...content, ...types, ...keys }
+}

package/src/helpers/imageContent.ts

@@ -0,0 +1,84 @@
+import type { ImageContent, ImageContentView } from "../content/image"
+
+export interface CroppedImage {
+	zoom: number
+	/** X coordinate of the crop rect on the original image */
+	x: number
+	/** Y coordinate of the crop rect on the original image */
+	y: number
+
+	/** The width of the crop rect over the original image */
+	cropWidth: number
+	/** The height of the crop rect over the original image */
+	cropHeight: number
+
+	/** Final (user defined via W input) width of the image */
+	width: number
+	/** Final (user defined via H input) height of the image */
+	height: number
+}
+
+export function buildCropURL(args: {
+	origin: ImageContent["origin"]
+	croppedImage: CroppedImage
+}): string {
+	const { origin, croppedImage } = args
+	const { x, y, width, height, cropHeight, cropWidth } = croppedImage
+
+	const url = new URL(origin.url)
+
+	const hasResize = origin.height !== height || origin.width !== width
+
+	const hasCrop = x !== 0 || y !== 0 || cropHeight !== origin.height || cropWidth !== origin.width
+
+	if (hasCrop) {
+		const crop = [x, y, cropWidth, cropHeight].map(Math.round).join(",")
+
+		url.searchParams.set("rect", crop)
+		url.searchParams.set("w", width.toString())
+		url.searchParams.set("h", height.toString())
+	}
+
+	if (hasResize) {
+		url.searchParams.set("w", width.toString())
+		url.searchParams.set("h", height.toString())
+	}
+
+	return url.toString()
+}
+
+export function getCroppedImage({ contentView }: { contentView: ImageContentView }): CroppedImage {
+	const {
+		edit: {
+			crop: { x, y },
+			zoom,
+		},
+		width,
+		height,
+		origin: { width: originWidth, height: originHeight },
+	} = contentView
+
+	let cropWidth
+	let cropHeight
+	const originAspect = originWidth / originHeight
+	const cropAspect = width / height
+	if (cropAspect >= originAspect) {
+		// crop and origin image would be the same width if zoom was equal to 1
+		cropWidth = originWidth / zoom
+		cropHeight = cropWidth / cropAspect
+	} else {
+		// crop and origin image would be the same height if zoom was equal to 1
+		cropHeight = originHeight / zoom
+		cropWidth = cropHeight * cropAspect
+	}
+
+	return {
+		x,
+		y,
+		width,
+		height,
+		zoom,
+		cropWidth,
+		cropHeight,
+	}
+}

package/src/helpers/sliceContent.ts

@@ -0,0 +1,86 @@
+import type { GroupItemContent } from "../content/group"
+import type { SharedSliceContent } from "../content/slice"
+import type {
+	CompositeSliceItemContent,
+	LegacySliceItemContent,
+	SharedSliceItemContent,
+} from "../content/slices"
+import type { SharedSliceVariationContentModel } from "../model/slice"
+
+export const legacyToShared = (
+	content: LegacySliceItemContent,
+	model: SharedSliceVariationContentModel,
+): SharedSliceItemContent => {
+	const sliceUUID = content.key.split("$")[1]
+
+	const primary: SharedSliceContent["primary"] = {}
+	const items: SharedSliceContent["items"] = []
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		// Group content
+		for (const item of content.widget.value) {
+			const value: GroupItemContent["value"] = []
+
+			for (const [key, nestable] of item.value) {
+				if (model.fields.items?.[key]) {
+					value.push([key, nestable])
+				}
+			}
+
+			items.push({ ...item, value })
+		}
+	} else if (model.fields.primary?.[content.name]) {
+		// Nestable content
+		primary[content.name] = content.widget
+	}
+
+	return {
+		key: `${model.sliceName}$${sliceUUID}`,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationID,
+			primary,
+			items,
+		},
+	}
+}
+
+export const compositeToShared = (
+	content: CompositeSliceItemContent,
+	model: SharedSliceVariationContentModel,
+): SharedSliceItemContent => {
+	const sliceUUID = content.key.split("$")[1]
+
+	const primary: SharedSliceContent["primary"] = {}
+	for (const [key, value] of Object.entries(content.widget.nonRepeat)) {
+		if (model.fields.primary?.[key]) {
+			primary[key] = value
+		}
+	}
+
+	const items: SharedSliceContent["items"] = []
+	for (const item of content.widget.repeat) {
+		const value: GroupItemContent["value"] = []
+
+		for (const [key, nestable] of item.value) {
+			if (model.fields.items?.[key]) {
+				value.push([key, nestable])
+			}
+		}
+
+		items.push({ ...item, value })
+	}
+
+	return {
+		key: `${model.sliceName}$${sliceUUID}`,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationID,
+			primary,
+			items,
+		},
+	}
+}