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

package/src/content/fields/withDefaultValues.ts

@@ -1,119 +0,0 @@
-import {
-	type NestableWidget,
-	type SlicePrimaryWidget,
-	Group,
-	GroupFieldType,
-} from "../../customtypes"
-import {
-	GroupContent,
-	GroupContentDefaultValue,
-	GroupContentType,
-	groupContentWithDefaultValues,
-	isGroupContent,
-} from "./GroupContent"
-import type { NestableContent } from "./nestable"
-import { NestableContentDefaultValue } from "./nestable"
-import type { SlicePrimaryContent } from "./slices/Slice/SlicePrimaryContent"
-
-export function withDefaultSlicePrimaryContentValues(
-	customType: Record<string, SlicePrimaryWidget>,
-	content: Partial<Record<string, SlicePrimaryContent>>,
-): Record<string, SlicePrimaryContent> {
-	const updatedContent = content as Record<string, SlicePrimaryContent>
-
-	for (const [widgetKey, widgetDef] of Object.entries(customType)) {
-		const widgetContent = content[widgetKey]
-
-		if (widgetContent === undefined) {
-			if (widgetDef.type === GroupFieldType) {
-				updatedContent[widgetKey] = groupContentWithDefaultValues(
-					widgetDef,
-					GroupContentDefaultValue,
-				)
-			} else {
-				const defaultValue = NestableContentDefaultValue(widgetDef)
-
-				if (defaultValue) {
-					updatedContent[widgetKey] = defaultValue
-				}
-			}
-
-			continue
-		}
-
-		if (widgetDef.type === GroupFieldType && isGroupContent(widgetContent)) {
-			updatedContent[widgetKey] = groupContentWithDefaultValues(
-				widgetDef,
-				widgetContent,
-			)
-		}
-	}
-
-	return updatedContent
-}
-
-export function withDefaultNestableContentValues(
-	customType: Record<string, NestableWidget>,
-	content: Record<string, NestableContent>,
-): Record<string, NestableContent> {
-	return Object.entries(customType).reduce<Record<string, NestableContent>>(
-		(updatedContent, [widgetKey, widgetDef]) => {
-			if (content[widgetKey] === undefined) {
-				const defaultValue = NestableContentDefaultValue(widgetDef)
-				return defaultValue !== undefined
-					? {
-							...updatedContent,
-							[widgetKey]: defaultValue,
-					  }
-					: updatedContent
-			}
-
-			return updatedContent
-		},
-		content,
-	)
-}
-
-export function repeatableContentWithDefaultNestableContentValues<
-	T extends {
-		value: [string, GroupContent | NestableContent][]
-	},
->(fields: Record<string, Group | NestableWidget>, 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,
-			)
-
-			if (fieldDef.type === "Group") {
-				const defaultValue = groupContentWithDefaultValues(
-					fieldDef,
-					(maybeContentItemValue?.[1] as GroupContent | undefined) ?? {
-						__TYPE__: GroupContentType,
-						value: [],
-					},
-				)
-				return {
-					...updatedContentItem,
-					value: [
-						// Since there was default content for the group, we need to remove the old one
-						...updatedContentItem.value.filter(([_key]) => _key !== key),
-						...(defaultValue ? [[key, defaultValue]] : []),
-					],
-				}
-			} else if (!maybeContentItemValue) {
-				const defaultValue = NestableContentDefaultValue(fieldDef)
-				return {
-					...updatedContentItem,
-					value: [
-						...updatedContentItem.value,
-						...(defaultValue ? [[key, defaultValue]] : []),
-					],
-				}
-			}
-
-			return updatedContentItem
-		}, contentItem)
-	})
-}

package/src/content/helpers.ts

@@ -1,25 +0,0 @@
-import * as t from "io-ts"
-import { v4 as uuid, validate as validateUuid } from "uuid"
-
-type WithContentType = { __TYPE__: string }
-export function hasContentType(obj: unknown): obj is WithContentType {
-	return typeof obj === "object" && obj !== null && "__TYPE__" in obj
-}
-
-const isUuid = (input: unknown): input is string =>
-	typeof input === "string" && validateUuid(input)
-
-const uuidWithFallback = new t.Type<string, string, unknown>(
-	"UUID",
-	isUuid,
-	(u, c) => {
-		if (typeof u === "undefined") return t.success(uuid())
-		if (isUuid(u)) return t.success(u)
-		return t.failure(u, c)
-	},
-	t.identity,
-)
-
-export function withKey<C extends t.Mixed>(codec: C) {
-	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
-}

package/src/content/index.ts

@@ -1,4 +0,0 @@
-export * from "./Document"
-export * from "./fields"
-export * from "./LegacyContentCtx"
-export * from "./utils"

package/src/content/utils.ts

@@ -1,145 +0,0 @@
-import { isRight } from "fp-ts/lib/Either"
-
-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
-
-export type ContentPathEntry = {
-	type:
-		| "CustomType"
-		| "Widget"
-		| "SharedSlice"
-		| "Slice"
-		| "LegacySlice"
-		| "GroupItem"
-		| "primary"
-		| "items"
-		| "RepeatableItem"
-	key: string
-}
-
-export type ContentPath = ReadonlyArray<ContentPathEntry>
-
-const PATH_SEPARATOR = "::"
-export const ContentPath = {
-	serialize(path: ContentPath): string {
-		return path.map((entry) => entry.key).join(PATH_SEPARATOR)
-	},
-	current(path: ContentPath): ContentPathEntry | undefined {
-		return path[path.length - 1]
-	},
-	append(path: string, strElement: string): string {
-		return path + PATH_SEPARATOR + strElement
-	},
-	make(
-		entries: Array<{
-			key?: ContentPathEntry["key"] | undefined
-			type: ContentPathEntry["type"]
-		}>,
-	): ContentPath {
-		return entries.reduce<ContentPath>((acc, { key, type }) => {
-			return key ? acc.concat({ key, type }) : acc
-		}, [])
-	},
-}

package/src/customtypes/CustomType.ts

@@ -1,280 +0,0 @@
-import { Either, left, right } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-import { withFallback } from "io-ts-types/lib/withFallback"
-
-import type { Fields } from "../utils"
-import { StringOrNull } from "../validators"
-import {
-	DynamicSection,
-	Sections,
-	StaticSection,
-	traverseSection,
-} from "./Section"
-import type { Group, NestableWidget, NestedGroup, UID } from "./widgets"
-import type { SharedSlice } from "./widgets/slices/SharedSlice"
-import type { DynamicSlice } from "./widgets/slices/Slice"
-import type { DynamicSlices } from "./widgets/slices/Slices"
-import type { DynamicWidget } from "./widgets/Widget"
-import type { StaticWidget } from "./widgets/Widget"
-
-export const CustomTypeFormat = {
-	page: "page",
-	custom: "custom",
-}
-
-class CustomTypeSlicesError extends Error {
-	slices: Array<string>
-	override message: string
-
-	constructor(slices: Array<string>) {
-		super()
-		this.slices = slices
-		this.message = this._formatError(slices)
-	}
-
-	_formatError(slicesRefs: Array<string>) {
-		const slicesMsg = slicesRefs.map((ref) => `\t - ${ref}`)
-		return `The following slices doesn't exists in your Prismic repository:
-${slicesMsg.join("\n")}
-`
-	}
-}
-
-function customTypeReader<T extends StaticSection | DynamicSection>(
-	codec: t.Type<T, unknown>,
-) {
-	return t.exact(
-		t.intersection([
-			t.type({
-				id: t.string,
-				label: StringOrNull,
-				repeatable: withFallback(t.boolean, true),
-				json: t.record(t.string, codec), //tab name => tab data
-				status: withFallback(t.boolean, true),
-			}),
-			t.partial({
-				format: withFallback(t.keyof(CustomTypeFormat), "custom"),
-			}),
-		]),
-	)
-}
-
-export const StaticCustomType = customTypeReader(StaticSection)
-export type StaticCustomType = t.TypeOf<typeof StaticCustomType>
-
-export const CustomType = customTypeReader(DynamicSection)
-export type CustomType = t.TypeOf<typeof CustomType>
-
-export function flattenWidgets(
-	customType: CustomType,
-): Array<[string, DynamicWidget]> {
-	return Object.entries(customType.json).reduce(
-		(
-			acc: Array<[string, DynamicWidget]>,
-			[, section]: [string, DynamicSection],
-		) => {
-			const sectionWidgets: Array<[string, DynamicWidget]> =
-				Object.entries(section)
-			return acc.concat(sectionWidgets)
-		},
-		[],
-	)
-}
-
-export function flattenSections(
-	customType: StaticCustomType,
-): Array<[string, StaticWidget]> {
-	return Object.entries(customType.json).reduce(
-		(
-			acc: Array<[string, StaticWidget]>,
-			[, section]: [string, StaticSection],
-		) => {
-			const sectionWidgets: Array<[string, StaticWidget]> =
-				Object.entries(section)
-			return acc.concat(sectionWidgets)
-		},
-		[],
-	)
-}
-
-function _retrieveSharedSlicesRef(customType: CustomType): Array<string> {
-	const slicezones = flattenWidgets(customType).filter(
-		([, widget]: [string, DynamicWidget]) => widget.type === "Slices",
-	) as Array<[string, DynamicSlices]>
-
-	const allSharedRefs = slicezones.reduce(
-		(acc: Array<string>, [, slicezone]) => {
-			const sharedRefs = Object.entries(
-				slicezone.config && slicezone.config.choices
-					? slicezone.config.choices
-					: {},
-			)
-				.filter(
-					([, slice]: [string, DynamicSlice]) => slice.type === "SharedSlice",
-				)
-				.map(([key]) => key)
-			return acc.concat(sharedRefs)
-		},
-		[],
-	)
-
-	return allSharedRefs
-}
-
-function _mapSharedSlicesRefs<A>(
-	customType: CustomType,
-): (mapFn: (ref: string) => A) => Array<A> {
-	const refs = _retrieveSharedSlicesRef(customType)
-
-	return function (mapFn: (ref: string) => A): Array<A> {
-		return refs.map(mapFn)
-	}
-}
-
-export function toStatic(
-	customType: CustomType,
-	sharedSlices: Map<string, SharedSlice>,
-): StaticCustomType {
-	const json = Object.entries(customType.json).reduce(
-		(
-			acc: { [key: string]: StaticSection },
-			[sectionKey, dynSection]: [string, DynamicSection],
-		) => {
-			return {
-				...acc,
-				[sectionKey]: Sections.toStatic(dynSection, sharedSlices),
-			}
-		},
-		{},
-	)
-
-	return { ...customType, json } as StaticCustomType
-}
-
-export function validateSlices(
-	customType: CustomType,
-	sharedSlices: Map<string, SharedSlice>,
-): Either<CustomTypeSlicesError, CustomType> {
-	const missingSlices = _mapSharedSlicesRefs<string | undefined>(customType)(
-		(ref: string) => {
-			const slice: SharedSlice | undefined = sharedSlices.get(ref)
-			const isMissing = !slice
-			if (isMissing) return ref
-			return
-		},
-	).filter(Boolean) as Array<string>
-
-	if (missingSlices.length > 0)
-		return left(new CustomTypeSlicesError(missingSlices))
-	else return right(customType)
-}
-
-export function collectWidgets(
-	customType: CustomType,
-	f: (ref: string, widget: DynamicWidget) => DynamicWidget | undefined,
-): CustomType {
-	const json = Object.entries(customType.json).reduce(
-		(acc, [sectionId, section]: [string, DynamicSection]) => {
-			const updatedSection = Object.entries(section).reduce(
-				(acc, [ref, widget]) => {
-					const updatedWidget = f(ref, widget)
-					if (updatedWidget) {
-						return { ...acc, [ref]: updatedWidget }
-					}
-					return acc
-				},
-				{},
-			)
-			return { ...acc, [sectionId]: updatedSection }
-		},
-		{},
-	)
-
-	return { ...customType, json }
-}
-
-export function filterMissingSharedSlices(
-	customType: CustomType,
-	sharedSlices: Map<string, SharedSlice>,
-): CustomType {
-	return collectWidgets(customType, (_widgetId, widget) => {
-		if (widget.type === "Slices") {
-			if (!widget.config || !widget.config.choices) return widget
-
-			const choices = Object.entries(widget.config.choices).reduce(
-				(acc, [sliceId, sliceValue]: [string, DynamicSlice]) => {
-					if (sliceValue.type === "SharedSlice" && !sharedSlices.get(sliceId))
-						return acc
-					return { ...acc, [sliceId]: sliceValue }
-				},
-				{},
-			)
-
-			const config = { ...widget.config, choices }
-
-			return { ...widget, config }
-		}
-
-		return widget
-	})
-}
-
-export function flattenCustomTypeFields(
-	customType: StaticCustomType,
-): Record<string, StaticWidget> {
-	return Object.values(customType.json).reduce(
-		(acc, tab) => ({
-			...acc,
-			...tab,
-		}),
-		{},
-	)
-}
-
-export function collectSharedSlices(customType: {
-	customTypeId: string
-	fields: Record<string, StaticWidget>
-}): Record<string, SharedSlice> {
-	return Object.entries(customType.fields).reduce((acc, [, w]) => {
-		if (w.type === "Slices" || w.type === "Choice") {
-			return {
-				...acc,
-				...Object.entries(w.config?.choices || {}).reduce(
-					(sliceZoneAcc, [sliceKey, sliceModel]) => {
-						return sliceModel.type === "SharedSlice"
-							? { ...sliceZoneAcc, [sliceKey]: sliceModel }
-							: sliceZoneAcc
-					},
-					{},
-				),
-			}
-		}
-		return acc
-	}, {})
-}
-
-export function traverseCustomType<
-	T extends CustomType | StaticCustomType,
->(args: {
-	customType: T
-	onField: Fields.OnFieldFn<UID | NestableWidget | Group | NestedGroup>
-}): T {
-	const { customType, onField } = args
-
-	let json: Record<string, typeof customType.json[string]> | undefined
-	for (const [key, section] of Object.entries(customType.json)) {
-		const newSection = traverseSection({
-			path: [key],
-			section,
-			onField,
-		})
-
-		if (newSection !== section) {
-			if (!json) json = { ...customType.json }
-			json[key] = newSection
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return json ? { ...customType, json } : customType
-}

package/src/customtypes/Section.ts

@@ -1,98 +0,0 @@
-import * as t from "io-ts"
-
-import { WidgetKey } from "../common"
-import type { Fields } from "../utils"
-import {
-	Group,
-	NestableWidget,
-	NestedGroup,
-	traverseGroup,
-	traverseSlices,
-	UID,
-} from "./widgets"
-import type { SharedSlice } from "./widgets/slices"
-import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget"
-
-export function sectionReader<T extends StaticWidget | DynamicWidget>(
-	codec: t.Type<T, unknown>,
-) {
-	return t.record(WidgetKey, codec) // WidgetId -> Widget Data
-}
-
-export const StaticSection = sectionReader(StaticWidget)
-export type StaticSection = t.TypeOf<typeof StaticSection>
-
-export const DynamicSection = sectionReader(DynamicWidget)
-export type DynamicSection = t.TypeOf<typeof DynamicSection>
-
-export const Sections = {
-	toStatic(
-		dynamic: DynamicSection,
-		sharedSlices: Map<string, SharedSlice>,
-	): StaticSection {
-		const section = Object.entries(dynamic).reduce(
-			(
-				acc: { [key: string]: StaticWidget },
-				[widgetKey, widget]: [string, DynamicWidget],
-			) => {
-				return { ...acc, [widgetKey]: Widgets.toStatic(widget, sharedSlices) }
-			},
-			{},
-		)
-		return section as StaticSection
-	},
-}
-
-export function traverseSection<
-	T extends DynamicSection | StaticSection,
->(args: {
-	path: ReadonlyArray<string>
-	section: T
-	onField: Fields.OnFieldFn<UID | NestableWidget | Group | NestedGroup>
-}): T {
-	const { path: prevPath, section: prevSection, onField } = args
-
-	let section: T | undefined
-	for (const [key, prevModel] of Object.entries(prevSection)) {
-		const path = [...prevPath, key]
-		let model
-		switch (prevModel.type) {
-			case "Choice":
-			case "Slices":
-				model = traverseSlices({
-					path,
-					slices: prevModel,
-					onField: onField as Fields.OnFieldFn<
-						NestableWidget | Group | NestedGroup
-					>,
-				})
-				break
-			case "Group":
-				model = onField({
-					path,
-					key,
-					field: traverseGroup({
-						path,
-						group: prevModel,
-						onField: onField as Fields.OnFieldFn<NestableWidget | NestedGroup>,
-					}),
-				})
-				break
-			default:
-				model = onField({
-					path,
-					key,
-					field: prevModel,
-				})
-				break
-		}
-
-		if (model !== prevModel) {
-			if (!section) section = { ...prevSection }
-			section[key] = model
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return section ?? prevSection
-}