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

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
-}

package/src/customtypes/diff/Variation.ts

@@ -1,167 +0,0 @@
-import { Objects } from "../../utils"
-import { Group, GroupFieldType } from "../widgets/Group"
-import type { NestableWidget } from "../widgets/nestable"
-import type { SlicePrimaryWidget } from "../widgets/slices"
-import type { Variation } from "../widgets/slices"
-import { type DiffChange, DiffOperation } from "./Changes"
-import type {
-	GroupWidgetWithFieldsDiff,
-	NestableWidgetDiff,
-	SlicePrimaryWidgetDiff,
-} from "./Widgets"
-
-export type VariationMetadata = Omit<Variation, "primary" | "items">
-export type VariationDiff = DiffChange<
-	Variation,
-	Partial<VariationMetadata> & {
-		primary?: Record<string, SlicePrimaryWidgetDiff>
-		items?: Record<string, NestableWidgetDiff>
-	}
->
-
-function compareVariationMeta(
-	variationA?: Variation,
-	variationB?: Variation,
-): Partial<VariationMetadata> {
-	const zippedVariations = Objects.zipObjects(variationA, variationB)
-
-	return Object.entries(zippedVariations).reduce((acc, [key, value]) => {
-		if (key === `primary` || key === "items") return acc
-
-		if (value?.left === value?.right) return acc
-		return { ...acc, [key]: value?.right }
-	}, {})
-}
-
-function compareWidgets<TWidget extends NestableWidget | Group>(
-	widgetsA?: { [key: string]: TWidget },
-	widgetsB?: { [key: string]: TWidget },
-):
-	| Record<
-			string,
-			SlicePrimaryWidget extends TWidget
-				? SlicePrimaryWidgetDiff
-				: NestableWidgetDiff
-	  >
-	| undefined {
-	const zippedWidgets = Objects.zipObjects(widgetsA, widgetsB)
-
-	const diffWidgets = Object.entries(zippedWidgets).reduce(
-		(acc, [widgetKey, widgetValue]) => {
-			if (
-				JSON.stringify(widgetValue?.left) === JSON.stringify(widgetValue?.right)
-			)
-				return acc
-
-			const changes = (() => {
-				if (!widgetValue?.left && !widgetValue?.right) return
-
-				if (widgetValue?.left && !widgetValue.right) {
-					return {
-						op: DiffOperation.Removed,
-					}
-				}
-
-				if (!widgetValue?.left && widgetValue?.right) {
-					if (widgetValue.right?.type === GroupFieldType) {
-						const group: GroupWidgetWithFieldsDiff = {
-							...widgetValue.right,
-							config: {
-								...widgetValue.right.config,
-								fields: {},
-							},
-						}
-						// On added groups, this basically marks all fields in the group as added
-						group.config.fields =
-							compareWidgets(undefined, widgetValue.right.config?.fields) || {}
-
-						return {
-							op: DiffOperation.Added,
-							value: group,
-						}
-					}
-
-					return {
-						op: DiffOperation.Added,
-						value: widgetValue.right,
-					}
-				}
-
-				if (widgetValue.right?.type === GroupFieldType) {
-					const group: GroupWidgetWithFieldsDiff = {
-						...widgetValue.right,
-						config: {
-							...widgetValue.right.config,
-							fields: {},
-						},
-					}
-					// On updated groups, this also compares the fields inside the group
-					group.config.fields =
-						compareWidgets(
-							widgetValue.left?.type === GroupFieldType
-								? widgetValue.left?.config?.fields
-								: undefined,
-							widgetValue.right.config?.fields,
-						) || {}
-
-					return {
-						op: DiffOperation.Updated,
-						value: group,
-					}
-				}
-
-				return {
-					op: DiffOperation.Updated,
-					value: widgetValue.right,
-				}
-			})()
-
-			if (!changes) return acc
-
-			return {
-				...acc,
-				[widgetKey]: changes,
-			}
-		},
-		{},
-	)
-
-	return Objects.isNotEmpty(diffWidgets) ? diffWidgets : undefined
-}
-
-export const VariationComparator = {
-	compare(
-		variationA?: Variation,
-		variationB?: Variation,
-	): VariationDiff | undefined {
-		if (variationA && !variationB)
-			return {
-				op: DiffOperation.Removed,
-			}
-		if (!variationA && variationB) {
-			return {
-				op: DiffOperation.Added,
-				value: variationB,
-			}
-		}
-
-		const diffMeta = compareVariationMeta(variationA, variationB)
-
-		const diffPrimary = compareWidgets(variationA?.primary, variationB?.primary)
-		const diffItems = compareWidgets(variationA?.items, variationB?.items)
-
-		const diffVariation = {
-			...diffMeta,
-			...(diffPrimary ? { primary: diffPrimary } : {}),
-			...(diffItems ? { items: diffItems } : {}),
-		}
-
-		if (Objects.isNotEmpty(diffVariation)) {
-			return {
-				op: DiffOperation.Updated,
-				value: diffVariation,
-			}
-		}
-		return undefined
-	},
-}

package/src/customtypes/diff/Widgets.ts

@@ -1,17 +0,0 @@
-import type { Group } from "../widgets"
-import type { NestableWidget } from "../widgets/nestable"
-import type { DiffChange } from "./Changes"
-
-export type NestableWidgetDiff = DiffChange<NestableWidget, NestableWidget>
-
-export type GroupWidgetWithFieldsDiff = Omit<Group, "config"> & {
-	config: Omit<Group["config"], "fields"> & {
-		fields?: Record<string, GroupWidgetDiff | NestableWidgetDiff>
-	}
-}
-export type GroupWidgetDiff = DiffChange<
-	GroupWidgetWithFieldsDiff,
-	GroupWidgetWithFieldsDiff
->
-
-export type SlicePrimaryWidgetDiff = NestableWidgetDiff | GroupWidgetDiff

package/src/customtypes/diff/index.ts

@@ -1,4 +0,0 @@
-export * from "./Changes"
-export * from "./SharedSlice"
-export * from "./Variation"
-export * from "./Widgets"

package/src/customtypes/index.ts

@@ -1,4 +0,0 @@
-export * from "./CustomType"
-export * from "./diff"
-export * from "./Section"
-export * from "./widgets"

package/src/customtypes/widgets/Group.ts

@@ -1,120 +0,0 @@
-import * as t from "io-ts"
-
-import { WidgetKey } from "../../common"
-import type { Fields } from "../../utils"
-import { StringOrNull } from "../../validators"
-import { NestableWidget } from "./nestable/NestableWidget"
-
-export const GroupFieldType = "Group"
-
-// We're obliged to use `t.Mixed` here, otherwise the factory would be
-// referencing itself and TypeScript would infer its type as `any`
-const createGroupConfig = <TWidgets extends t.Mixed>(widgets: TWidgets) =>
-	t.exact(
-		t.partial({
-			label: StringOrNull,
-			repeat: t.boolean,
-			fields: t.record(WidgetKey, widgets),
-		}),
-	)
-
-// We're obliged to use `t.Mixed` here, otherwise the factory would be
-// referencing itself and TypeScript would infer its type as `any`
-const createGroup = <TWidgets extends t.Mixed>(widgets: TWidgets) =>
-	t.exact(
-		t.intersection([
-			t.type({
-				type: t.literal(GroupFieldType),
-			}),
-			t.partial({
-				fieldset: StringOrNull,
-				icon: t.string,
-				description: t.string,
-				config: createGroupConfig(widgets),
-			}),
-		]),
-	)
-
-export const NestedGroupConfig = createGroupConfig(NestableWidget)
-export type NestedGroupConfig = t.TypeOf<typeof NestedGroupConfig>
-
-export const NestedGroup = createGroup(NestableWidget)
-export type NestedGroup = t.TypeOf<typeof NestedGroup>
-
-export const GroupConfig = createGroupConfig(
-	t.union([NestableWidget, NestedGroup]),
-)
-export type GroupConfig = t.TypeOf<typeof GroupConfig>
-
-export const Group = createGroup(t.union([NestableWidget, NestedGroup]))
-export type Group = t.TypeOf<typeof Group>
-
-export function traverseNestedGroup(args: {
-	path: ReadonlyArray<string>
-	group: NestedGroup
-	onField: Fields.OnFieldFn<NestableWidget>
-}): NestedGroup {
-	const { path: prevPath, group, onField } = args
-
-	if (!group.config?.fields) return group
-
-	let fields: Record<string, NestableWidget> | undefined
-	for (const [key, field] of Object.entries(group.config.fields)) {
-		const path = [...prevPath, key]
-		const newField = onField({
-			path,
-			key,
-			field,
-		})
-
-		if (field !== newField) {
-			if (!fields) fields = { ...group.config.fields }
-			fields[key] = newField
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return fields ? { ...group, config: { ...group.config, fields } } : group
-}
-
-export function traverseGroup(args: {
-	path: ReadonlyArray<string>
-	group: Group
-	onField: Fields.OnFieldFn<NestableWidget | NestedGroup>
-}): Group {
-	const { path: prevPath, group, onField } = args
-
-	if (!group.config?.fields) return group
-
-	let fields: Record<string, NestableWidget | NestedGroup> | undefined
-	for (const [key, prevField] of Object.entries(group.config.fields)) {
-		const path = [...prevPath, key]
-		let field
-		switch (prevField.type) {
-			case "Group":
-				field = traverseNestedGroup({
-					path,
-					group: prevField,
-					onField: onField as Fields.OnFieldFn<NestableWidget>,
-				})
-				break
-			default:
-				field = prevField
-				break
-		}
-
-		const newField = onField({
-			path,
-			key,
-			field,
-		})
-
-		if (field !== newField) {
-			if (!fields) fields = { ...group.config.fields }
-			fields[key] = newField
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return fields ? { ...group, config: { ...group.config, fields } } : group
-}