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

package/src/customtypes/widgets/UID.ts

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

package/src/customtypes/widgets/Widget.ts

@@ -1,83 +0,0 @@
-import * as t from "io-ts"
-
-import { Group, GroupFieldType } from "./Group"
-import {
-	BooleanFieldType,
-	ColorFieldType,
-	DateFieldType,
-	EmbedFieldType,
-	GeoPointFieldType,
-	ImageFieldType,
-	IntegrationFieldType,
-	LinkFieldType,
-	NumberFieldType,
-	RangeFieldType,
-	RichTextFieldType,
-	SelectFieldType,
-	SeparatorFieldType,
-	TableFieldType,
-	TextFieldType,
-	TimestampFieldType,
-} from "./nestable"
-import { NestableWidget } from "./nestable/NestableWidget"
-import type { SharedSlice } from "./slices/SharedSlice"
-import {
-	DynamicSlices,
-	LegacySlicesFieldType,
-	Slices,
-	SlicesFieldType,
-	StaticSlices,
-} from "./slices/Slices"
-import { UID, UIDFieldType } from "./UID"
-
-export function widgetReader<T extends StaticSlices | DynamicSlices>(
-	codec: t.Type<T, unknown>,
-) {
-	return t.union([UID, NestableWidget, Group, codec])
-}
-
-export const StaticWidget = widgetReader(StaticSlices)
-export type StaticWidget = t.TypeOf<typeof StaticWidget>
-
-export const DynamicWidget = widgetReader(DynamicSlices)
-export type DynamicWidget = t.TypeOf<typeof DynamicWidget>
-
-export const FieldType = t.keyof({
-	[ColorFieldType]: null,
-	[BooleanFieldType]: null,
-	[NumberFieldType]: null,
-	[EmbedFieldType]: null,
-	[GeoPointFieldType]: null,
-	[DateFieldType]: null,
-	[RangeFieldType]: null,
-	[RichTextFieldType]: null,
-	[SelectFieldType]: null,
-	[SeparatorFieldType]: null,
-	[TableFieldType]: null,
-	[TextFieldType]: null,
-	[TimestampFieldType]: null,
-	[LinkFieldType]: null,
-	[ImageFieldType]: null,
-	[IntegrationFieldType]: null,
-	[UIDFieldType]: null,
-	[GroupFieldType]: null,
-	[SlicesFieldType]: null,
-	[LegacySlicesFieldType]: null,
-})
-
-export type FieldType = t.TypeOf<typeof FieldType>
-
-export const Widgets = {
-	toStatic(
-		widget: DynamicWidget,
-		sharedSlices: Map<string, SharedSlice>,
-	): StaticWidget {
-		switch (widget.type) {
-			case "Choice":
-			case "Slices":
-				return Slices.toStatic(widget, sharedSlices)
-			default:
-				return widget
-		}
-	},
-}

package/src/customtypes/widgets/index.ts

@@ -1,6 +0,0 @@
-export * from "./Group"
-export * from "./nestable"
-export * from "./shared"
-export * from "./slices"
-export * from "./UID"
-export * from "./Widget"

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

@@ -1,29 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-
-export const BooleanFieldType = "Boolean"
-
-export const BooleanConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		default_value: t.boolean,
-		placeholder_true: t.string,
-		placeholder_false: t.string,
-	}),
-)
-
-export type BooleanConfig = t.TypeOf<typeof BooleanConfig>
-
-export const BooleanField = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(BooleanFieldType),
-		}),
-		t.partial({
-			config: BooleanConfig,
-		}),
-	]),
-)
-
-export type BooleanField = t.TypeOf<typeof BooleanField>

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-
-export const GeoPointFieldType = "GeoPoint"
-
-export const GeoPointConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-	}),
-)
-export type GeoPointConfig = t.TypeOf<typeof GeoPointConfig>
-
-export const GeoPoint = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(GeoPointFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: GeoPointConfig,
-		}),
-	]),
-)
-export type GeoPoint = t.TypeOf<typeof GeoPoint>

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

@@ -1,39 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-import ImageConstraint from "../shared/ImageConstraint"
-
-export const ImageFieldType = "Image"
-
-export const Thumbnail = t.exact(
-	t.intersection([
-		t.type({
-			name: t.string,
-		}),
-		ImageConstraint,
-	]),
-)
-export type Thumbnail = t.TypeOf<typeof Thumbnail>
-
-export const ImageConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		placeholder: t.string,
-		constraint: ImageConstraint,
-		thumbnails: t.readonlyArray(Thumbnail),
-	}),
-)
-export type ImageConfig = t.TypeOf<typeof ImageConfig>
-
-export const Image = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(ImageFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: ImageConfig,
-		}),
-	]),
-)
-export type Image = t.TypeOf<typeof Image>

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

@@ -1,26 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-
-export const IntegrationFieldType = "IntegrationFields"
-export const IntegrationFieldConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		placeholder: t.string,
-		catalog: t.string,
-	}),
-)
-export type IntegrationFieldConfig = t.TypeOf<typeof IntegrationFieldConfig>
-
-export const IntegrationField = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(IntegrationFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: IntegrationFieldConfig,
-		}),
-	]),
-)
-export type IntegrationField = t.TypeOf<typeof IntegrationField>

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

@@ -1,313 +0,0 @@
-import { either } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-import { withFallback } from "io-ts-types/lib/withFallback"
-
-import { StringOrNull } from "../../../validators"
-
-const arrayString = (
-	entries:
-		| string
-		| string[]
-		| {
-				[x: string]: {
-					name: string
-				}[]
-		  }
-		| undefined,
-) => {
-	if (entries instanceof Array) {
-		const isValidEntries = entries.reduce(
-			(acc, l) => acc && typeof l === "string",
-			true,
-		)
-		if (isValidEntries) return t.success(entries)
-	}
-	return
-}
-
-const plainString = (
-	entries:
-		| string
-		| string[]
-		| {
-				[x: string]: {
-					name: string
-				}[]
-		  }
-		| undefined,
-) => {
-	if (typeof entries === "string") {
-		return t.success([entries])
-	}
-	return
-}
-
-const MasksArrayString = new t.Type<ReadonlyArray<string>, object, unknown>(
-	"MasksArrayString",
-	(u: unknown): u is ReadonlyArray<string> => {
-		return u instanceof Array
-	},
-	(u: unknown, context: t.Context) => {
-		return either.chain(
-			t.union([t.array(t.string), t.string]).validate(u, context),
-			(masks) => {
-				return arrayString(masks) || plainString(masks) || t.failure(u, context)
-			},
-		)
-	},
-	(res) => res,
-)
-
-// Field selection in content relationship fields doesn't support nested groups.
-
-const CustomTypeLevel2FieldGroupFields = new t.Type<
-	readonly string[],
-	readonly string[]
->(
-	"CustomTypeLevel2FieldGroupFields",
-	(u: unknown): u is readonly string[] =>
-		Array.isArray(u) && u.every((item) => typeof item === "string"),
-	(u: unknown, context: t.Context) =>
-		either.chain(t.array(t.string).validate(u, context), (fields) => {
-			// duplicates not allowed
-			const filtered = new Set(fields)
-			return filtered.size === fields.length
-				? t.success(fields)
-				: t.failure(u, context, "Fields have duplicates.")
-		}),
-	(a) => a,
-)
-
-const CustomTypeLevel2Field = t.union([
-	t.strict({
-		id: t.string,
-		fields: CustomTypeLevel2FieldGroupFields,
-	}),
-	t.string,
-])
-
-const CustomTypeLevel2Fields = new t.Type<
-	readonly t.TypeOf<typeof CustomTypeLevel2Field>[],
-	readonly t.OutputOf<typeof CustomTypeLevel2Field>[]
->(
-	"CustomTypeLevel2Fields",
-	(u: unknown): u is readonly t.TypeOf<typeof CustomTypeLevel2Field>[] =>
-		Array.isArray(u) && u.every((item) => CustomTypeLevel2Field.is(item)),
-	(u: unknown, context: t.Context) =>
-		either.chain(
-			t.array(CustomTypeLevel2Field).validate(u, context),
-			(fields) => {
-				// duplicates not allowed
-				const filtered = new Set(
-					fields.map((field) => (typeof field === "string" ? field : field.id)),
-				)
-				return filtered.size === fields.length
-					? t.success(fields)
-					: t.failure(u, context, "Fields have duplicates.")
-			},
-		),
-	(a) => a,
-)
-
-const CustomTypeLevel2 = t.union([
-	t.string,
-	t.strict({
-		id: t.string,
-		fields: CustomTypeLevel2Fields,
-	}),
-])
-
-const CustomTypesLevel2 = new t.Type<
-	readonly t.TypeOf<typeof CustomTypeLevel2>[],
-	readonly t.OutputOf<typeof CustomTypeLevel2>[]
->(
-	"CustomTypesLevel2",
-	(u: unknown): u is readonly t.TypeOf<typeof CustomTypeLevel2>[] =>
-		Array.isArray(u) && u.every((item) => CustomTypeLevel2.is(item)),
-	(u: unknown, context: t.Context) =>
-		either.chain(t.array(CustomTypeLevel2).validate(u, context), (cts) => {
-			// duplicates not allowed
-			const filtered = new Set(
-				cts.map((ct) => (typeof ct === "string" ? ct : ct.id)),
-			)
-			return filtered.size === cts.length
-				? t.success(cts)
-				: t.failure(u, context, "Custom types have duplicates.")
-		}),
-	(a) => a,
-)
-
-const CustomTypeLevel1FieldCustomTypes = t.strict({
-	id: t.string,
-	customtypes: CustomTypesLevel2,
-})
-
-const CustomTypeLevel1FieldGroupField = t.union([
-	CustomTypeLevel1FieldCustomTypes,
-	t.string,
-])
-
-const CustomTypeLevel1FieldGroupFields = new t.Type<
-	readonly t.TypeOf<typeof CustomTypeLevel1FieldGroupField>[],
-	readonly t.OutputOf<typeof CustomTypeLevel1FieldGroupField>[]
->(
-	"CustomTypeLevel1FieldGroupFields",
-	(
-		u: unknown,
-	): u is readonly t.TypeOf<typeof CustomTypeLevel1FieldGroupField>[] =>
-		Array.isArray(u) &&
-		u.every((item) => CustomTypeLevel1FieldGroupField.is(item)),
-	(u: unknown, context: t.Context) =>
-		either.chain(
-			t.array(CustomTypeLevel1FieldGroupField).validate(u, context),
-			(fields) => {
-				// duplicates not allowed
-				const filtered = new Set(
-					fields.map((field) => (typeof field === "string" ? field : field.id)),
-				)
-				return filtered.size === fields.length
-					? t.success(fields)
-					: t.failure(u, context, "Fields have duplicates.")
-			},
-		),
-	(a) => a,
-)
-
-const CustomTypeLevel1Field = t.union([
-	t.strict({
-		id: t.string,
-		fields: CustomTypeLevel1FieldGroupFields,
-	}),
-	CustomTypeLevel1FieldCustomTypes,
-	t.string,
-])
-
-const CustomTypeLevel1Fields = new t.Type<
-	readonly t.TypeOf<typeof CustomTypeLevel1Field>[],
-	readonly t.OutputOf<typeof CustomTypeLevel1Field>[]
->(
-	"CustomTypeLevel1Fields",
-	(u: unknown): u is readonly t.TypeOf<typeof CustomTypeLevel1Field>[] =>
-		Array.isArray(u) && u.every((item) => CustomTypeLevel1Field.is(item)),
-	(u: unknown, context: t.Context) =>
-		either.chain(
-			t.array(CustomTypeLevel1Field).validate(u, context),
-			(fields) => {
-				// duplicates not allowed
-				const filtered = new Set(
-					fields.map((field) => (typeof field === "string" ? field : field.id)),
-				)
-				return filtered.size === fields.length
-					? t.success(fields)
-					: t.failure(u, context, "Fields have duplicates.")
-			},
-		),
-	(a) => a,
-)
-
-const CustomTypeLevel1 = t.union([
-	t.string,
-	t.strict({
-		id: t.string,
-		fields: CustomTypeLevel1Fields,
-	}),
-])
-
-export const CustomTypes = new t.Type<
-	readonly t.TypeOf<typeof CustomTypeLevel1>[],
-	readonly t.OutputOf<typeof CustomTypeLevel1>[]
->(
-	"CustomTypes",
-	(u: unknown): u is readonly t.TypeOf<typeof CustomTypeLevel1>[] =>
-		Array.isArray(u) && u.every((item) => CustomTypeLevel1.is(item)),
-	(u: unknown, context: t.Context) =>
-		either.chain(t.array(CustomTypeLevel1).validate(u, context), (cts) => {
-			// if a ct appears more than once as a string, we allow it (legacy)
-			// if a ct appears once as a string and then again via object (or vice versa), we don't allow it
-			// if a ct appears more than once as an object, we don't allow it
-			const strings = new Set<string>()
-			const objects = new Set<string>()
-			for (const ct of cts) {
-				let failed = false
-				if (typeof ct === "string") {
-					failed = objects.has(ct)
-					strings.add(ct)
-				} else {
-					const { id } = ct
-					failed = strings.has(id) || objects.has(id)
-					objects.add(id)
-				}
-				if (failed)
-					return t.failure(u, context, "Custom types have duplicates.")
-			}
-
-			if (objects.size > 1) {
-				return t.failure(
-					u,
-					context,
-					"Cannot have multiple custom types with fields selection.",
-				)
-			}
-
-			if (strings.size > 0 && objects.size > 0) {
-				return t.failure(
-					u,
-					context,
-					"Cannot mix custom types as strings and objects with fields.",
-				)
-			}
-
-			return t.success(cts)
-		}),
-	(a) => a,
-)
-
-export const LinkFieldType = "Link"
-
-export const LinkConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		useAsTitle: t.boolean,
-		placeholder: t.string,
-		select: withFallback(
-			t.union([
-				t.literal("media"),
-				t.literal("document"),
-				t.literal("web"),
-				t.null,
-			]),
-			null,
-		),
-		customtypes: CustomTypes,
-		masks: MasksArrayString, // legacy definition of the custom types allowed
-		tags: MasksArrayString,
-		allowTargetBlank: t.boolean,
-		allowText: t.boolean,
-
-		/**
-		 * `repeat` property is used to allow multiple links to be added.
-		 * `undefined` means that the field is not repeatable (hence repeat = false).
-		 */
-		repeat: t.boolean,
-
-		/**
-		 * `variants` allows an option to be picked from a list (e.g. "primary"). To
-		 * be considered, the list must have at least one item.
-		 */
-		variants: t.array(t.string),
-	}),
-)
-export type LinkConfig = t.TypeOf<typeof LinkConfig>
-
-export const Link = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(LinkFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: LinkConfig,
-		}),
-	]),
-)
-export type Link = t.TypeOf<typeof Link>

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

@@ -1,40 +0,0 @@
-import * as t from "io-ts"
-
-import { BooleanField } from "./BooleanField"
-import { Color } from "./Color"
-import { Date } from "./Date"
-import { Embed } from "./Embed"
-import { GeoPoint } from "./GeoPoint"
-import { Image } from "./Image"
-import { IntegrationField } from "./IntegrationField"
-import { Link } from "./Link"
-import { Number } from "./Number"
-import { Range } from "./Range"
-import { RichText } from "./RichText"
-import { Select } from "./Select"
-import { Separator } from "./Separator"
-import { Table } from "./Table"
-import { Text } from "./Text"
-import { Timestamp } from "./Timestamp"
-
-export const NestableWidget = t.union([
-	Color,
-	BooleanField,
-	Embed,
-	GeoPoint,
-	Date,
-	Number,
-	Range,
-	RichText,
-	Select,
-	Separator,
-	Table,
-	Text,
-	Timestamp,
-	Link,
-	Image,
-	IntegrationField,
-])
-
-export type NestableWidget = t.TypeOf<typeof NestableWidget>
-export type NestableFieldTypes = NestableWidget["type"]

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

@@ -1,30 +0,0 @@
-import * as t from "io-ts"
-import { NumberFromString } from "io-ts-types/lib/NumberFromString"
-
-import { StringOrNull } from "../../../validators"
-
-export const NumberFieldType = "Number"
-
-export const NumberConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		placeholder: t.string,
-		min: t.union([t.number, NumberFromString]),
-		max: t.union([t.number, NumberFromString]),
-		step: t.union([t.number, NumberFromString]),
-	}),
-)
-export type NumberConfig = t.TypeOf<typeof NumberConfig>
-
-export const Number = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(NumberFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: NumberConfig,
-		}),
-	]),
-)
-export type Number = t.TypeOf<typeof Number>