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

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

package/src/utils/Objects.ts

@@ -1,53 +0,0 @@
-import { isRight } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-
-export function zipObjects<A, B = A>(
-	objLeft?: Partial<Record<string, A>> | undefined,
-	objRight?: Partial<Record<string, B>> | undefined,
-): Partial<Record<string, { left?: A | undefined; right?: B | undefined }>> {
-	const allKeys = [
-		...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {}))),
-	]
-
-	return allKeys.reduce<
-		Record<string, { left?: A | undefined; right?: B | undefined }>
-	>((acc, key) => {
-		const left = objLeft?.[key]
-		const right = objRight?.[key]
-		return {
-			...acc,
-			[key]: { left, right },
-		}
-	}, {})
-}
-
-export function isNotEmpty<A extends object>(obj: A): boolean {
-	return Boolean(Object.keys(obj).length)
-}
-
-export function withOptionals<T extends object>(
-	object: T,
-	optionals: Array<[keyof T, T[keyof T] | null | undefined]>,
-): T {
-	return {
-		...object,
-		...optionals.reduce((acc, [key, value]) => {
-			return value ? { ...acc, [key]: value } : acc
-		}, {}),
-	}
-}
-
-const recordCodec = t.record(t.string, t.unknown)
-export function isObject(value: unknown): value is Record<string, unknown> {
-	return isRight(recordCodec.decode(value))
-}
-
-export function mapValues<T, O>(
-	record: Record<string, T>,
-	fn: (value: T, key: string) => O,
-): Record<string, O> {
-	return Object.entries<T>(record).reduce<Record<string, O>>(
-		(acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }),
-		{},
-	)
-}

package/src/utils/index.ts

@@ -1,4 +0,0 @@
-export * as HexaColorCode from "../common/HexaColorCode"
-export * as Arrays from "./Arrays"
-export * as Fields from "./Fields"
-export * as Objects from "./Objects"

package/src/validators/BasicTypes.ts

@@ -1,55 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { withCustomError } from "./function"
-
-export const String = withCustomError(
-	t.string,
-	() => "The value must be a string",
-)
-export const StringOrNull = withCustomError(
-	t.union([t.string, t.null]),
-	() => "The value must be a string or null",
-)
-export const Number = withCustomError(
-	t.number,
-	() => "The value must be a number",
-)
-export const NumberOrNull = withCustomError(
-	t.union([t.number, t.null]),
-	() => "The value must be a number or null",
-)
-export const Boolean = withCustomError(
-	t.boolean,
-	() => "The value must be a boolean",
-)
-
-export const EmptyObject = t.UnknownRecord.pipe(
-	new t.Type(
-		"emptyObject",
-		(u: unknown): u is Record<never, never> => t.UnknownRecord.is(u),
-		(u: Record<string, unknown>, c: t.Context) => {
-			if (Object.keys(u).length > 0)
-				return t.failure(u, c, "The object is not empty.")
-			return t.success({})
-		},
-		t.identity,
-	),
-)
-
-export const EmptyArray = new t.Type<never[], never[], unknown>(
-	"emptyArray",
-	(u: unknown): u is [] => t.UnknownArray.is(u) && u.length === 0,
-	(u: unknown, c: t.Context) => {
-		return pipe(
-			t.UnknownArray.decode(u),
-			either.chain((parsedArray) => {
-				if (parsedArray.length > 0)
-					return t.failure(u, c, "The array is not empty.")
-				return t.success(new Array<never>())
-			}),
-		)
-	},
-	() => [],
-)

package/src/validators/DateFromString.ts

@@ -1,19 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import { String } from "."
-
-export default new t.Type<Date, string, unknown>(
-	"dateFromString",
-	(u): u is Date => u instanceof Date,
-	(u, c) =>
-		pipe(
-			String.validate(u, c),
-			chain((s) => {
-				const d = new Date(s)
-				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
-			}),
-		),
-	(date) => date.toISOString(),
-)

package/src/validators/DateFromStringOrNumber.ts

@@ -1,17 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export default new t.Type<Date, Date, unknown>(
-	"dateFromStringOrNumber",
-	(u): u is Date => u instanceof Date,
-	(u, c) =>
-		pipe(
-			t.union([t.number, t.string]).validate(u, c),
-			chain((s) => {
-				const d = new Date(s)
-				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
-			}),
-		),
-	(date) => date,
-)

package/src/validators/DateFromTsMs.ts

@@ -1,17 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export default new t.Type<Date, number, unknown>(
-	"dateFromTsMs",
-	(u): u is Date => u instanceof Date,
-	(u, c) =>
-		pipe(
-			t.number.validate(u, c),
-			chain((s) => {
-				const d = new Date(s)
-				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
-			}),
-		),
-	(date) => date.getTime(),
-)

package/src/validators/DefaultOrElse.ts

@@ -1,24 +0,0 @@
-import { isRight } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-
-import { EmptyArray, EmptyObject } from "./BasicTypes"
-
-export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
-	return (codec: t.Type<A, O>) =>
-		new t.Type<A | null, O | undefined>(
-			`DefaultOrElse<${inputValidator.name}, ${codec.name}>`,
-			(u: unknown): u is A | null => null === u || codec.is(u),
-			(u: unknown, c) => {
-				if (isRight(inputValidator.validate(u, c))) return t.success(null)
-				return codec.validate(u, c)
-			},
-			(chunk) => (chunk ? codec.encode(chunk) : undefined),
-		)
-}
-
-export const NullOrElse = <A, O = A>(codec: t.Type<A, O>) =>
-	DefaultOrElse<null, A, O>(t.null)(codec)
-export const EmptyObjectOrElse = <A, O = A>(codec: t.Type<A, O>) =>
-	DefaultOrElse<Record<never, never>, A, O>(EmptyObject)(codec)
-export const EmptyArrayOrElse = <A, O = A>(codec: t.Type<A, O>) =>
-	DefaultOrElse<never[], A, O>(EmptyArray)(codec)

package/src/validators/IntFromNumber.ts

@@ -1,22 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type IntFromNumberC = t.Type<t.Int, number, unknown>
-
-/** A codec that succeeds if a number can be parsed to an integer */
-export default new t.Type<t.Int, number, unknown>(
-	"IntFromNumber",
-	t.Int.is,
-	(u, c) =>
-		pipe(
-			t.number.validate(u, c),
-			chain((n) => {
-				if (t.Int.is(n)) return t.success(n)
-				else {
-					return t.success(Math.round(n) as t.Int)
-				}
-			}),
-		),
-	t.Int.encode,
-)

package/src/validators/IntFromPixels.ts

@@ -1,32 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type IntFromPixelsC = t.Type<t.Int, string, unknown>
-
-const PixelsRegex = /^([0-9]+)px$/
-/**
- * A codec that succeeds if a string representing pixels (eg: "200px") can be
- * parsed to an integer
- */
-export default new t.Type<t.Int, string, unknown>(
-	"IntFromPixels",
-	t.Int.is,
-	(u, c) =>
-		pipe(
-			t.string.validate(u, c),
-			chain((strPixels) => {
-				try {
-					const matched = strPixels.match(PixelsRegex)
-					if (!matched) return t.failure(u, c)
-
-					/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-					const parsed = parseInt(matched[1]!) as t.Int
-					return t.success(parsed)
-				} catch {
-					return t.failure(u, c)
-				}
-			}),
-		),
-	String,
-)

package/src/validators/NonEmptyString.ts

@@ -1,8 +0,0 @@
-import * as t from "io-ts"
-
-import { refineType, withCustomError } from "./function"
-
-export default withCustomError(
-	refineType(t.string, "nonEmptyString", (s) => s.trim().length > 0),
-	() => "The value must be a non-empty string",
-)