@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

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>

package/src/customtypes/widgets/nestable/Range.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 RangeFieldType = "Range"
-
-export const RangeConfig = 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 RangeConfig = t.TypeOf<typeof RangeConfig>
-
-export const Range = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(RangeFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: RangeConfig,
-		}),
-	]),
-)
-export type Range = t.TypeOf<typeof Range>

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

@@ -1,215 +0,0 @@
-import { either } from "fp-ts/"
-import { getOrElseW } from "fp-ts/lib/Either"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../validators"
-import ImageConstraint from "../shared/ImageConstraint"
-
-export const RichTextFieldType = "StructuredText"
-
-export const DEFAULT_OPTION = "paragraph"
-
-export type RichTextNodeType =
-	typeof RichTextNodeType[keyof typeof RichTextNodeType]
-export const RichTextNodeType = {
-	heading1: "heading1",
-	heading2: "heading2",
-	heading3: "heading3",
-	heading4: "heading4",
-	heading5: "heading5",
-	heading6: "heading6",
-	paragraph: "paragraph",
-	strong: "strong",
-	em: "em",
-	preformatted: "preformatted",
-	hyperlink: "hyperlink",
-	image: "image",
-	embed: "embed",
-	list: "list-item",
-	orderedList: "o-list-item",
-	rtl: "rtl",
-} as const
-
-export const RichTextNodeTypeCodec = t.keyof({
-	[RichTextNodeType.heading1]: null,
-	[RichTextNodeType.heading2]: null,
-	[RichTextNodeType.heading3]: null,
-	[RichTextNodeType.heading4]: null,
-	[RichTextNodeType.heading5]: null,
-	[RichTextNodeType.heading6]: null,
-	[RichTextNodeType.paragraph]: null,
-	[RichTextNodeType.strong]: null,
-	[RichTextNodeType.em]: null,
-	[RichTextNodeType.preformatted]: null,
-	[RichTextNodeType.hyperlink]: null,
-	[RichTextNodeType.image]: null,
-	[RichTextNodeType.embed]: null,
-	[RichTextNodeType.list]: null,
-	[RichTextNodeType.orderedList]: null,
-	[RichTextNodeType.rtl]: null,
-})
-
-const RichTextOptions = new t.Type<string, string, unknown>(
-	"RichTextOptions",
-	(u: unknown): u is string => typeof u === "string",
-	(u: unknown) => {
-		return pipe(
-			t.union([t.string, t.null]).decode(u),
-			either.map((s: string | null) => {
-				if (!s) return DEFAULT_OPTION
-				const entries = s.split(",").map((e: string) => e.trim())
-				const filtered = entries.filter((entry) => {
-					return getOrElseW(() => undefined)(
-						RichTextNodeTypeCodec.decode(entry),
-					)
-				})
-				if (!filtered.length) return DEFAULT_OPTION
-
-				return filtered.join(",")
-			}),
-		)
-	},
-	(a) => a,
-)
-
-const NoLabels = (
-	labels:
-		| string
-		| ReadonlyArray<string>
-		| {
-				[x: string]: ReadonlyArray<{
-					name: string
-				}>
-		  }
-		| null,
-) => {
-	if (!labels) return t.success([])
-	return
-}
-
-const LabelsAsObject = (
-	labels:
-		| string
-		| ReadonlyArray<string>
-		| {
-				[x: string]: ReadonlyArray<{
-					name: string
-				}>
-		  }
-		| null,
-) => {
-	if (labels instanceof Object) {
-		const labelsObj = labels as { [x: string]: { name: string }[] }
-
-		// empty labels
-		if (!Object.entries(labelsObj).length) return t.success([])
-
-		// weird case labels with empty key as parent
-		if (labelsObj[""]) {
-			return t.success(labelsObj[""].map((l) => l.name))
-		}
-
-		const convertedObjectToArray = Object.entries(labelsObj)
-			.reduce<ReadonlyArray<string>>((acc, [, labelsEntries]) => {
-				return acc.concat(labelsEntries.map((l) => l.name))
-			}, [])
-			.filter(Boolean)
-
-		return t.success(convertedObjectToArray)
-	}
-	return
-}
-
-const LabelsAsArray = (
-	labels:
-		| string
-		| ReadonlyArray<string>
-		| {
-				[x: string]: ReadonlyArray<{
-					name: string
-				}>
-		  }
-		| null,
-) => {
-	if (labels instanceof Array) {
-		const isValidLabels = labels.reduce(
-			(acc, l) => acc && typeof l === "string",
-			true,
-		)
-		if (isValidLabels) return t.success(labels)
-	}
-	return
-}
-
-const LabelsAsString = (
-	labels:
-		| string
-		| ReadonlyArray<string>
-		| {
-				[x: string]: ReadonlyArray<{
-					name: string
-				}>
-		  }
-		| null,
-) => {
-	if (typeof labels === "string") {
-		return t.success([labels])
-	}
-	return
-}
-
-const RichTextLabels = new t.Type<ReadonlyArray<string>, object, unknown>(
-	"RichTextLabels",
-	(u: unknown): u is ReadonlyArray<string> => {
-		return u instanceof Array
-	},
-	(u: unknown, context: t.Context) => {
-		const legacyValidator = t.record(
-			t.string,
-			t.readonlyArray(t.record(t.literal("name"), t.string)),
-		)
-		const validator = t.readonlyArray(t.string)
-
-		return pipe(
-			t.union([legacyValidator, validator, t.string, t.null]).decode(u),
-			either.chain((labels) => {
-				return (
-					NoLabels(labels) ||
-					LabelsAsArray(labels) ||
-					LabelsAsObject(labels) ||
-					LabelsAsString(labels) ||
-					t.failure(u, context)
-				)
-			}),
-		)
-	},
-	(res) => res,
-)
-
-export const RichTextConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		placeholder: t.string,
-		useAsTitle: t.boolean,
-		single: RichTextOptions,
-		multi: RichTextOptions,
-		imageConstraint: ImageConstraint,
-		labels: RichTextLabels,
-		allowTargetBlank: t.boolean,
-	}),
-)
-export type RichTextConfig = t.TypeOf<typeof RichTextConfig>
-
-export const RichText = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(RichTextFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: RichTextConfig,
-		}),
-	]),
-)
-export type RichText = t.TypeOf<typeof RichText>

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

@@ -1,34 +0,0 @@
-import * as t from "io-ts"
-
-import {
-	StringFromBoolean,
-	StringFromNumber,
-	StringOrNull,
-} from "../../../validators"
-
-export const SelectFieldType = "Select"
-
-export const SelectConfig = t.exact(
-	t.partial({
-		label: StringOrNull,
-		placeholder: t.string,
-		default_value: t.string,
-		options: t.readonlyArray(
-			t.union([t.string, StringFromNumber, StringFromBoolean]),
-		),
-	}),
-)
-export type SelectConfig = t.TypeOf<typeof SelectConfig>
-
-export const Select = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(SelectFieldType),
-		}),
-		t.partial({
-			fieldset: StringOrNull,
-			config: SelectConfig,
-		}),
-	]),
-)
-export type Select = t.TypeOf<typeof Select>

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

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