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

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>

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