@prismicio/types-internal 3.17.0 → 4.0.0-canary.65d3262

package/src/customtypes/widgets/nestable/Table.ts

@@ -1,38 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-import { RichTextNodeType } from "./RichText"
-
-export const TableFieldType = "Table"
-
-const TableConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-	}),
-)
-
-export type TableConfig = t.TypeOf<typeof TableConfig>
-
-export const Table = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(TableFieldType),
-		}),
-		t.partial({
-			config: TableConfig,
-		}),
-	]),
-)
-export type Table = t.TypeOf<typeof Table>
-
-export const TableCell = {
-	type: "StructuredText" as const,
-	config: {
-		multi: [
-			RichTextNodeType.paragraph,
-			RichTextNodeType.strong,
-			RichTextNodeType.em,
-			RichTextNodeType.hyperlink,
-		].join(","),
-	},
-}

package/src/customtypes/widgets/nestable/Text.ts

@@ -1,27 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-
-export const TextFieldType = "Text"
-
-export const TextConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		useAsTitle: t.boolean,
-		placeholder: t.string,
-	}),
-)
-export type TextConfig = t.TypeOf<typeof TextConfig>
-
-export const Text = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(TextFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: TextConfig,
-		}),
-	]),
-)
-export type Text = t.TypeOf<typeof Text>

package/src/customtypes/widgets/nestable/Timestamp.ts

@@ -1,27 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-
-export const TimestampFieldType = "Timestamp"
-
-export const TimestampConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		placeholder: t.string,
-		default: t.string,
-	}),
-)
-export type TimestampConfig = t.TypeOf<typeof TimestampConfig>
-
-export const Timestamp = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(TimestampFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: TimestampConfig,
-		}),
-	]),
-)
-export type Timestamp = t.TypeOf<typeof Timestamp>

package/src/customtypes/widgets/nestable/index.ts

@@ -1,17 +0,0 @@
-export * from "./BooleanField"
-export * from "./Color"
-export * from "./Date"
-export * from "./Embed"
-export * from "./GeoPoint"
-export * from "./Image"
-export * from "./IntegrationField"
-export * from "./Link"
-export * from "./NestableWidget"
-export * from "./Number"
-export * from "./Range"
-export * from "./RichText"
-export * from "./Select"
-export * from "./Separator"
-export * from "./Table"
-export * from "./Text"
-export * from "./Timestamp"

package/src/customtypes/widgets/shared/ImageConstraint.ts

@@ -1,41 +0,0 @@
-import { either } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-import { IntFromString } from "io-ts-types/lib/IntFromString"
-
-import { IntFromNumber, IntFromPixels } from "../../../validators"
-
-const SideConstraint = new t.Type<number | null, unknown, unknown>(
-	"SideConstraints",
-	(u: unknown): u is number | null => {
-		return !u || typeof u === "number"
-	},
-	(u: unknown, context: t.Context) => {
-		return either.chain(
-			t
-				.union([
-					t.literal("auto"),
-					t.literal(""),
-					t.Int,
-					IntFromString,
-					IntFromNumber,
-					IntFromPixels,
-					t.null,
-				])
-				.validate(u, context),
-			(constraint) => {
-				if (constraint === "auto" || constraint === "") return t.success(null)
-				return t.success(constraint)
-			},
-		)
-	},
-	(res) => res,
-)
-
-const ImageConstraint = t.partial({
-	width: SideConstraint,
-	height: SideConstraint,
-})
-
-type ImageConstraint = t.TypeOf<typeof ImageConstraint>
-
-export default ImageConstraint

package/src/customtypes/widgets/shared/index.ts

@@ -1 +0,0 @@
-export { default as ImageConstraint } from "./ImageConstraint"

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -1,79 +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"
-import type { DynamicSlice, StaticSlice } from "./Slice"
-
-export const CompositeSliceType = "Slice"
-
-export const CompositeSliceConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-	}),
-)
-export type CompositeSliceConfig = t.TypeOf<typeof CompositeSliceConfig>
-
-export const CompositeSlice = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(CompositeSliceType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			description: t.string,
-			icon: t.string,
-			display: t.string,
-			"non-repeat": t.record(WidgetKey, NestableWidget),
-			repeat: t.record(WidgetKey, NestableWidget),
-			config: CompositeSliceConfig,
-		}),
-	]),
-)
-export type CompositeSlice = t.TypeOf<typeof CompositeSlice>
-
-export function isCompositeSlice(
-	slice: DynamicSlice | StaticSlice,
-): slice is CompositeSlice {
-	return slice.type === "Slice"
-}
-
-export function traverseCompositeSlice(args: {
-	path: ReadonlyArray<string>
-	slice: CompositeSlice
-	onField: Fields.OnFieldFn<NestableWidget>
-}): CompositeSlice {
-	const { path: prevPath, slice, onField } = args
-
-	let nonRepeat: Record<string, NestableWidget> | undefined
-	for (const [key, field] of Object.entries(slice["non-repeat"] ?? {})) {
-		const path = [...prevPath, "non-repeat", key]
-		const newField = onField({ path, key, field })
-
-		if (field !== newField) {
-			if (!nonRepeat) nonRepeat = { ...slice["non-repeat"] }
-			nonRepeat[key] = newField
-		}
-	}
-
-	let repeat: Record<string, NestableWidget> | undefined
-	for (const [key, field] of Object.entries(slice.repeat ?? {})) {
-		const path = [...prevPath, "repeat", key]
-		const newField = onField({ path, key, field })
-
-		if (field !== newField) {
-			if (!repeat) repeat = { ...slice.repeat }
-			repeat[key] = newField
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return repeat || nonRepeat
-		? {
-				...slice,
-				...(nonRepeat && { "non-repeat": nonRepeat }),
-				...(repeat && { repeat }),
-		  }
-		: slice
-}

package/src/customtypes/widgets/slices/LegacySlice.ts

@@ -1,15 +0,0 @@
-import * as t from "io-ts"
-
-import { NestedGroup } from "../Group"
-import { NestableWidget } from "../nestable/NestableWidget"
-import type { DynamicSlice, StaticSlice } from "./Slice"
-
-export const LegacySlice = t.union([NestableWidget, NestedGroup])
-
-export type LegacySlice = t.TypeOf<typeof LegacySlice>
-
-export function isLegacySlice(
-	slice: DynamicSlice | StaticSlice,
-): slice is LegacySlice {
-	return slice.type !== "Slice" && slice.type !== "SharedSlice"
-}

package/src/customtypes/widgets/slices/SharedSlice.ts

@@ -1,152 +0,0 @@
-import * as t from "io-ts"
-import { withFallback } from "io-ts-types/lib/withFallback"
-
-import { WidgetKey } from "../../../common"
-import type { Fields } from "../../../utils"
-import { Group, NestedGroup, traverseGroup } from "../Group"
-import { NestableWidget } from "../nestable/NestableWidget"
-import type { SharedSliceRef } from "./SharedSliceRef"
-import type { DynamicSlice, StaticSlice } from "./Slice"
-import { SlicePrimaryWidget } from "./SlicePrimaryWidget"
-
-const IMAGE_PLACEHOLDER_URL =
-	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"
-
-export const Variation = t.exact(
-	t.intersection([
-		t.type({
-			id: t.string,
-			name: t.string,
-			description: t.string,
-			imageUrl: withFallback(t.string, IMAGE_PLACEHOLDER_URL),
-			docURL: t.string,
-			version: t.string,
-		}),
-		t.partial({
-			display: t.string,
-			primary: t.record(WidgetKey, SlicePrimaryWidget),
-			items: t.record(WidgetKey, NestableWidget),
-		}),
-	]),
-)
-
-export type Variation = t.TypeOf<typeof Variation>
-
-// VariationFields is used exclusively for the slices migration, LegacySlice -> SharedSlice
-export type VariationFields = {
-	type: "SharedSlice"
-	sliceName: string
-	variationId: string
-	fields: Pick<Variation, "primary" | "items">
-}
-
-export const SharedSliceType = "SharedSlice"
-
-const LegacyPath = t.string
-const VariationId = t.string
-
-export const SharedSlice = t.exact(
-	t.intersection([
-		t.type({
-			id: t.string,
-			type: t.literal(SharedSliceType),
-			name: t.string,
-			variations: t.readonlyArray(Variation),
-		}),
-		t.partial({
-			description: t.string,
-			legacyPaths: t.record(LegacyPath, VariationId),
-		}),
-	]),
-)
-
-export type SharedSlice = t.TypeOf<typeof SharedSlice>
-
-export function isStaticSharedSlice(slice: StaticSlice): slice is SharedSlice {
-	return slice.type === "SharedSlice"
-}
-
-export function isDynamicSharedSlice(
-	slice: DynamicSlice,
-): slice is SharedSliceRef {
-	return slice.type === "SharedSlice"
-}
-
-export function traverseVariation(args: {
-	path: ReadonlyArray<string>
-	variation: Variation
-	onField: Fields.OnFieldFn<NestableWidget | Group | NestedGroup>
-}): Variation {
-	const { path: prevPath, variation, onField } = args
-
-	let primary: Record<string, NestableWidget | Group> | undefined
-	for (const [key, prevField] of Object.entries(variation.primary ?? {})) {
-		const path = [...prevPath, "primary", key]
-		let field
-		switch (prevField.type) {
-			case "Group":
-				field = traverseGroup({
-					path,
-					group: prevField,
-					onField: onField as Fields.OnFieldFn<NestableWidget | NestedGroup>,
-				})
-				break
-			default:
-				field = prevField
-				break
-		}
-
-		const newField = onField({ path, key, field })
-		if (field !== newField) {
-			if (!primary) primary = { ...variation.primary }
-			primary[key] = newField
-		}
-	}
-
-	let items: Record<string, NestableWidget> | undefined
-	for (const [key, prevField] of Object.entries(variation.items ?? {})) {
-		const path = [...prevPath, "items", key]
-		const newField = (onField as Fields.OnFieldFn<NestableWidget>)({
-			path,
-			key,
-			field: prevField,
-		})
-		if (prevField !== newField) {
-			if (!items) items = { ...variation.items }
-			items[key] = newField
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return primary || items
-		? { ...variation, ...(primary && { primary }), ...(items && { items }) }
-		: variation
-}
-
-export function traverseSharedSlice(args: {
-	path: ReadonlyArray<string>
-	slice: SharedSlice
-	onField: Fields.OnFieldFn<NestableWidget | Group | NestedGroup>
-}): SharedSlice {
-	const { path: prevPath, slice, onField } = args
-
-	let variations: Variation[] | undefined
-	for (let i = 0; i < slice.variations.length; i++) {
-		const variation = slice.variations[i]
-		if (!variation) continue
-		const path = [...prevPath, variation.id]
-		const newVariation = traverseVariation({
-			path,
-			variation,
-			onField,
-		})
-
-		if (newVariation !== variation) {
-			if (!variations) variations = [...slice.variations]
-			variations[i] = newVariation
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return variations ? { ...slice, variations } : slice
-}

package/src/customtypes/widgets/slices/SharedSliceRef.ts

@@ -1,10 +0,0 @@
-import * as t from "io-ts"
-
-import { SharedSliceType } from "./SharedSlice"
-
-export const SharedSliceRef = t.exact(
-	t.type({
-		type: t.literal(SharedSliceType),
-	}),
-)
-export type SharedSliceRef = t.TypeOf<typeof SharedSliceRef>

package/src/customtypes/widgets/slices/Slice.ts

@@ -1,7 +0,0 @@
-import type { CompositeSlice } from "./CompositeSlice"
-import type { LegacySlice } from "./LegacySlice"
-import type { SharedSlice } from "./SharedSlice"
-import type { SharedSliceRef } from "./SharedSliceRef"
-
-export type DynamicSlice = CompositeSlice | LegacySlice | SharedSliceRef
-export type StaticSlice = CompositeSlice | LegacySlice | SharedSlice

package/src/customtypes/widgets/slices/SlicePrimaryWidget.ts

@@ -1,12 +0,0 @@
-import * as t from "io-ts"
-
-import { Group } from "../Group"
-import { NestableWidget } from "../nestable"
-
-export const SlicePrimaryWidget = t.union([NestableWidget, Group])
-
-export type SlicePrimaryWidget = t.TypeOf<typeof SlicePrimaryWidget>
-export type SlicePrimaryFieldTypes = SlicePrimaryWidget["type"]
-
-export const isSlicePrimaryWidget = (u: unknown): u is SlicePrimaryWidget =>
-	NestableWidget.is(u) || Group.is(u)

package/src/customtypes/widgets/slices/Slices.ts

@@ -1,184 +0,0 @@
-import * as t from "io-ts"
-
-import { WidgetKey } from "../../../common"
-import type { Fields } from "../../../utils"
-import { StringOrNull } from "../../../validators"
-import { Group, NestedGroup, traverseNestedGroup } from "../Group"
-import type { NestableWidget } from "../nestable"
-import { CompositeSlice, traverseCompositeSlice } from "./CompositeSlice"
-import { LegacySlice } from "./LegacySlice"
-import { SharedSlice, traverseSharedSlice } from "./SharedSlice"
-import { SharedSliceRef } from "./SharedSliceRef"
-
-export const LegacySlicesFieldType = "Choice"
-export const SlicesFieldType = "Slices"
-
-export const SlicesLabels = t.union([
-	t.record(
-		t.string,
-		t.readonlyArray(
-			t.exact(
-				t.intersection([
-					t.type({
-						name: t.string,
-					}),
-					t.partial({
-						display: t.string,
-					}),
-				]),
-			),
-		),
-	),
-	t.null,
-])
-export type SlicesLabels = t.TypeOf<typeof SlicesLabels>
-
-export function slicesConfigReader<T extends SharedSlice | SharedSliceRef>(
-	codec: t.Type<T, unknown>,
-) {
-	return t.exact(
-		t.partial({
-			label: StringOrNull,
-			labels: SlicesLabels,
-			choices: t.record(
-				WidgetKey,
-				t.union([LegacySlice, CompositeSlice, codec]),
-			),
-		}),
-	)
-}
-export const StaticSlicesConfig = slicesConfigReader(SharedSlice)
-export type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>
-
-export const DynamicSlicesConfig = slicesConfigReader(SharedSliceRef)
-export type DynamicSlicesConfig = t.TypeOf<typeof DynamicSlicesConfig>
-
-const SlicesConfig = {
-	toStatic(
-		config: DynamicSlicesConfig,
-		sharedSlices: Map<string, SharedSlice>,
-	): StaticSlicesConfig {
-		const choices: {
-			[key: string]: LegacySlice | CompositeSlice | SharedSlice
-		} = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
-			if (slice.type === "SharedSlice") {
-				const sharedSlice = sharedSlices.get(ref)
-				if (sharedSlice) return { ...acc, [ref]: sharedSlice }
-				else return acc
-			} else {
-				return { ...acc, [ref]: slice }
-			}
-		}, {})
-
-		return { ...config, choices } as StaticSlicesConfig
-	},
-}
-
-export function slicesReader<
-	T extends StaticSlicesConfig | DynamicSlicesConfig,
->(codec: t.Type<T, unknown>) {
-	return t.exact(
-		t.intersection([
-			t.type({
-				type: t.keyof({
-					[SlicesFieldType]: null,
-					[LegacySlicesFieldType]: null,
-				}),
-			}),
-			t.partial({
-				fieldset: StringOrNull,
-				config: codec,
-			}),
-		]),
-	)
-}
-
-export const StaticSlices = slicesReader(StaticSlicesConfig)
-export type StaticSlices = t.TypeOf<typeof StaticSlices>
-
-export const DynamicSlices = slicesReader(DynamicSlicesConfig)
-export type DynamicSlices = t.TypeOf<typeof DynamicSlices>
-
-export const Slices = {
-	toStatic(
-		slices: DynamicSlices,
-		sharedSlices: Map<string, SharedSlice>,
-	): StaticSlices {
-		if (!slices.config) return slices as StaticSlices
-		else {
-			return {
-				...slices,
-				config: SlicesConfig.toStatic(slices.config, sharedSlices),
-			}
-		}
-	},
-}
-
-export function traverseSlices<T extends DynamicSlices | StaticSlices>(args: {
-	path: ReadonlyArray<string>
-	slices: T
-	onField: Fields.OnFieldFn<NestableWidget | Group | NestedGroup>
-}): T {
-	const { path: prevPath, slices, onField } = args
-
-	if (!slices.config?.choices) return slices
-
-	let choices: Record<string, typeof slices.config.choices[string]> | undefined
-	for (const [key, prevModel] of Object.entries(slices.config.choices)) {
-		const path = [...prevPath, key]
-		let model
-		switch (prevModel.type) {
-			case "Slice":
-				model = traverseCompositeSlice({
-					path,
-					slice: prevModel,
-					onField: onField as Fields.OnFieldFn<NestableWidget>,
-				})
-				break
-			case "SharedSlice":
-				if ("variations" in prevModel)
-					model = traverseSharedSlice({
-						path,
-						slice: prevModel as SharedSlice,
-						onField,
-					})
-				else model = prevModel
-				break
-			// Group and other fields are technically possible because of legacy slices.
-			case "Group":
-				model = onField({
-					path,
-					key,
-					field: traverseNestedGroup({
-						path,
-						group: prevModel,
-						onField: onField as Fields.OnFieldFn<NestableWidget>,
-					}),
-				})
-				break
-			default:
-				model = onField({
-					path,
-					key,
-					field: prevModel,
-				})
-				break
-		}
-
-		if (model !== prevModel) {
-			if (!choices) choices = { ...slices.config.choices }
-			choices[key] = model as typeof slices.config.choices[string]
-		}
-	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return choices
-		? {
-				...slices,
-				config: {
-					...slices.config,
-					choices,
-				},
-		  }
-		: slices
-}

package/src/customtypes/widgets/slices/SlicesTypes.ts

@@ -1,11 +0,0 @@
-import * as t from "io-ts"
-
-import { CompositeSliceType } from "./CompositeSlice"
-import { SharedSliceType } from "./SharedSlice"
-
-export const SlicesTypes = t.keyof({
-	[CompositeSliceType]: null,
-	[SharedSliceType]: null,
-})
-
-export type SlicesTypes = t.TypeOf<typeof SlicesTypes>

package/src/customtypes/widgets/slices/index.ts

@@ -1,8 +0,0 @@
-export * from "./CompositeSlice"
-export * from "./LegacySlice"
-export * from "./SharedSlice"
-export * from "./SharedSliceRef"
-export * from "./Slice"
-export * from "./SlicePrimaryWidget"
-export * from "./Slices"
-export * from "./SlicesTypes"

package/src/utils/Arrays.ts

@@ -1,12 +0,0 @@
-export function toRecord<A extends object>(
-	arr: ReadonlyArray<A>,
-	key: (obj: A) => string,
-) {
-	return arr.reduce((acc, entry) => {
-		const k = key(entry)
-		return {
-			...acc,
-			[k]: entry,
-		}
-	}, {})
-}

package/src/utils/DocumentId.ts

@@ -1,8 +0,0 @@
-import * as t from "io-ts"
-
-import { refineType, withCustomError } from "../validators/function"
-
-export const DocumentId = withCustomError(
-	refineType(t.string, "DocumentId", (s) => s.length === 16),
-	() => "DocumentId must be a 16 character string",
-)

package/src/utils/Fields.ts

@@ -1,4 +0,0 @@
-import type { Group, NestableWidget, NestedGroup, UID } from "../customtypes"
-
-export type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> =
-	(args: { path: ReadonlyArray<string>; key: string; field: T }) => T