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

package/src/content/fields/nestable/FieldContent/ColorContent.ts

@@ -1,49 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { ColorFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isColorContent = (u: unknown): u is ColorContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Color"
-
-export const ColorLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<ColorContent, WithTypes<string>, unknown>(
-		"ColorLegacy",
-		isColorContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					ColorContent.encode({
-						value: f,
-						type: ColorFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: ColorContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: ColorFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const ColorContent = t.strict({
-	type: t.literal(ColorFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type ColorContent = t.TypeOf<typeof ColorContent>

package/src/content/fields/nestable/FieldContent/DateContent.ts

@@ -1,49 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { DateFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isDateContent = (u: unknown): u is DateContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Date"
-
-export const DateLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<DateContent, WithTypes<string>, unknown>(
-		"DateLegacy",
-		isDateContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					DateContent.encode({
-						value: f,
-						type: DateFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: DateContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: DateFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const DateContent = t.strict({
-	type: t.literal(DateFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type DateContent = t.TypeOf<typeof DateContent>

package/src/content/fields/nestable/FieldContent/NumberContent.ts

@@ -1,49 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { NumberFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isNumberContent = (u: unknown): u is NumberContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Number"
-
-export const NumberLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<NumberContent, WithTypes<string>, unknown>(
-		"NumberLegacy",
-		isNumberContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					NumberContent.encode({
-						value: f,
-						type: NumberFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: NumberContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: NumberFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const NumberContent = t.strict({
-	type: t.literal(NumberFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type NumberContent = t.TypeOf<typeof NumberContent>

package/src/content/fields/nestable/FieldContent/RangeContent.ts

@@ -1,49 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { RangeFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isRangeContent = (u: unknown): u is RangeContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Range"
-
-export const RangeLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<RangeContent, WithTypes<string>, unknown>(
-		"RangeLegacy",
-		isRangeContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					RangeContent.encode({
-						value: f,
-						type: RangeFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: RangeContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: RangeFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const RangeContent = t.strict({
-	type: t.literal(RangeFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type RangeContent = t.TypeOf<typeof RangeContent>

package/src/content/fields/nestable/FieldContent/SelectContent.ts

@@ -1,60 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { Select, SelectFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isSelectContent = (u: unknown): u is SelectContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Select"
-
-export const SelectLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<SelectContent, WithTypes<string>, unknown>(
-		"SelectLegacy",
-		isSelectContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					SelectContent.encode({
-						value: f,
-						type: SelectFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: SelectContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: SelectFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const SelectContent = t.strict({
-	type: t.literal(SelectFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type SelectContent = t.TypeOf<typeof SelectContent>
-
-export const SelectContentDefaultValue = (
-	field: Select,
-): SelectContent | undefined =>
-	field.config?.default_value
-		? {
-				__TYPE__: FieldContentType,
-				type: SelectFieldType,
-				value: field.config.default_value || "",
-		  }
-		: undefined

package/src/content/fields/nestable/FieldContent/TextContent.ts

@@ -1,49 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { TextFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isTextContent = (u: unknown): u is TextContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Text"
-
-export const TextLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<TextContent, WithTypes<string>, unknown>(
-		"TextLegacy",
-		isTextContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					TextContent.encode({
-						value: f,
-						type: TextFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: TextContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: TextFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const TextContent = t.strict({
-	type: t.literal(TextFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type TextContent = t.TypeOf<typeof TextContent>

package/src/content/fields/nestable/FieldContent/TimestampContent.ts

@@ -1,49 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { TimestampFieldType } from "../../../../customtypes/widgets"
-import TrimmedString from "../../../../validators/TrimmedString"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
-import { hasContentType, hasFieldContentType } from "../../../utils"
-import { FieldContentType } from "./common"
-
-export const isTimestampContent = (u: unknown): u is TimestampContent =>
-	hasContentType(u) &&
-	u.__TYPE__ === FieldContentType &&
-	hasFieldContentType(u) &&
-	u.type === "Timestamp"
-
-export const TimestampLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<TimestampContent, WithTypes<string>, unknown>(
-		"TimestampLegacy",
-		isTimestampContent,
-		(u) => {
-			return pipe(
-				TrimmedString.decode(u),
-				either.map((f) =>
-					TimestampContent.encode({
-						value: f,
-						type: TimestampFieldType,
-						__TYPE__: FieldContentType,
-					}),
-				),
-			)
-		},
-
-		(b: TimestampContent) => {
-			return {
-				content: b.value,
-				types: { [ctx.keyOfType]: TimestampFieldType },
-				keys: {},
-			}
-		},
-	)
-
-export const TimestampContent = t.strict({
-	type: t.literal(TimestampFieldType),
-	value: TrimmedString,
-	__TYPE__: t.literal(FieldContentType),
-})
-
-export type TimestampContent = t.TypeOf<typeof TimestampContent>

package/src/content/fields/nestable/FieldContent/common.ts

@@ -1 +0,0 @@
-export const FieldContentType = "FieldContent"

package/src/content/fields/nestable/FieldContent/index.ts

@@ -1,40 +0,0 @@
-import * as t from "io-ts"
-
-import { ColorContent } from "./ColorContent"
-import { DateContent } from "./DateContent"
-import { NumberContent } from "./NumberContent"
-import { RangeContent } from "./RangeContent"
-import { SelectContent } from "./SelectContent"
-import { TextContent } from "./TextContent"
-import { TimestampContent } from "./TimestampContent"
-
-export const FieldType = t.keyof({
-	Text: null,
-	Date: null,
-	Timestamp: null,
-	Color: null,
-	Number: null,
-	Range: null,
-	Select: null,
-})
-export type FieldType = t.TypeOf<typeof FieldType>
-
-export const FieldContent = t.union([
-	DateContent,
-	ColorContent,
-	NumberContent,
-	RangeContent,
-	SelectContent,
-	TextContent,
-	TimestampContent,
-])
-export type FieldContent = t.TypeOf<typeof FieldContent>
-
-export * from "./ColorContent"
-export * from "./common"
-export * from "./DateContent"
-export * from "./NumberContent"
-export * from "./RangeContent"
-export * from "./SelectContent"
-export * from "./TextContent"
-export * from "./TimestampContent"

package/src/content/fields/nestable/GeoPointContent.ts

@@ -1,48 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
-
-export const GeoPointContentType = "GeoPointContent"
-
-export const isGeoPointContent = (u: unknown): u is GeoPointContent =>
-	hasContentType(u) && u.__TYPE__ === GeoPointContentType
-
-const legacyReader = t.strict({
-	position: t.strict({
-		lat: t.number,
-		lng: t.number,
-	}),
-})
-type GeoPointLegacy = t.TypeOf<typeof legacyReader>
-
-export const GeoPointLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<GeoPointContent, WithTypes<GeoPointLegacy>, unknown>(
-		"GeoPointLegacy",
-		isGeoPointContent,
-		(u) => {
-			return pipe(
-				legacyReader.decode(u),
-				either.map((geo) =>
-					GeoPointContent.encode({ ...geo, __TYPE__: GeoPointContentType }),
-				),
-			)
-		},
-
-		(geo: GeoPointContent) => ({
-			content: { position: geo.position },
-			types: { [ctx.keyOfType]: "GeoPoint" },
-			keys: {},
-		}),
-	)
-
-export const GeoPointContent = t.intersection([
-	legacyReader,
-	t.strict({
-		__TYPE__: t.literal(GeoPointContentType),
-	}),
-])
-
-export type GeoPointContent = t.TypeOf<typeof GeoPointContent>

package/src/content/fields/nestable/ImageContent.ts

@@ -1,196 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { withOptionals } from "../../../utils/Objects"
-import { NonEmptyStringOrNull, StringOrNull } from "../../../validators"
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
-
-export const ImageContentType = "ImageContent"
-
-export const isImageContent = (u: unknown): u is ImageContent =>
-	hasContentType(u) && u.__TYPE__ === ImageContentType
-
-const originReader = t.exact(
-	t.type({
-		id: t.string,
-		url: t.string,
-		width: t.number,
-		height: t.number,
-	}),
-)
-
-export const ImageContentView = t.exact(
-	t.intersection([
-		t.type({
-			origin: originReader,
-			width: t.number,
-			height: t.number,
-			edit: t.type({
-				zoom: t.number,
-				crop: t.type({
-					x: t.number,
-					y: t.number,
-				}),
-				background: t.string,
-			}),
-		}),
-		t.partial({
-			url: t.string,
-			credits: NonEmptyStringOrNull,
-			alt: NonEmptyStringOrNull,
-			provider: StringOrNull,
-		}),
-	]),
-)
-export type ImageContentView = t.TypeOf<typeof ImageContentView>
-
-const legacyReader = t.intersection([
-	ImageContentView,
-	t.partial({
-		thumbnails: t.record(t.string, ImageContentView),
-	}),
-])
-
-type ImageLegacy = t.TypeOf<typeof legacyReader>
-
-export const ImageLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<ImageContent, WithTypes<ImageLegacy>, unknown>(
-		"ImageLegacy",
-		isImageContent,
-		(u) => {
-			return pipe(
-				legacyReader.decode(u),
-				either.map((i) =>
-					ImageContent.encode({ ...i, __TYPE__: ImageContentType }),
-				),
-			)
-		},
-
-		(i: ImageContent) => {
-			return {
-				content: withOptionals<ImageLegacy>(
-					{
-						edit: i.edit,
-						height: i.height,
-						origin: i.origin,
-						width: i.width,
-					},
-					[
-						["alt", i.alt],
-						["credits", i.credits],
-						["provider", i.provider],
-						["thumbnails", i.thumbnails],
-						["url", i.url],
-					],
-				),
-				types: { [ctx.keyOfType]: "Image" },
-				keys: {},
-			}
-		},
-	)
-
-export const ImageContent = t.intersection([
-	legacyReader,
-	t.strict({
-		__TYPE__: t.literal(ImageContentType),
-	}),
-])
-
-export type ImageContent = t.TypeOf<typeof ImageContent>
-
-// Helpers to build image crop URLs (used in editor, migration-api, and prismic-mocks)
-interface BuildCropUrlArgs {
-	origin: ImageContent["origin"]
-	/** Image crop parameters */
-	croppedImage: CroppedImage
-}
-
-export function buildCropUrl(args: BuildCropUrlArgs) {
-	const { origin, croppedImage } = args
-	const { x, y, width, height, cropHeight, cropWidth } = croppedImage
-
-	const url = new URL(origin.url)
-
-	const hasResize = origin.height !== height || origin.width !== width
-
-	const hasCrop =
-		x !== 0 ||
-		y !== 0 ||
-		cropHeight !== origin.height ||
-		cropWidth !== origin.width
-
-	if (hasCrop) {
-		const crop = [x, y, cropWidth, cropHeight].map(Math.round).join(",")
-
-		url.searchParams.set("rect", crop)
-		url.searchParams.set("w", width.toString())
-		url.searchParams.set("h", height.toString())
-	}
-
-	if (hasResize) {
-		url.searchParams.set("w", width.toString())
-		url.searchParams.set("h", height.toString())
-	}
-
-	return url.toString()
-}
-
-export interface CroppedImage {
-	zoom: number
-	/** X coordinate of the crop rect on the original image */
-	x: number
-	/** Y coordinate of the crop rect on the original image */
-	y: number
-
-	/** The width of the crop rect over the original image */
-	cropWidth: number
-	/** The height of the crop rect over the original image */
-	cropHeight: number
-
-	/** Final (user defined via W input) height of the image */
-	width: number
-	/** Final (user defined via H input) height of the image */
-	height: number
-}
-
-export function getCroppedImage({
-	contentView,
-}: {
-	contentView: ImageContentView
-}): CroppedImage {
-	const {
-		edit: {
-			crop: { x, y },
-			zoom,
-		},
-		width,
-		height,
-		origin: { width: originWidth, height: originHeight },
-	} = contentView
-
-	let cropWidth
-	let cropHeight
-	const originAspect = originWidth / originHeight
-	const cropAspect = width / height
-	if (cropAspect >= originAspect) {
-		// crop and origin image would be the same width if zoom was equal to 1
-		cropWidth = originWidth / zoom
-		cropHeight = cropWidth / cropAspect
-	} else {
-		// crop and origin image would be the same height if zoom was equal to 1
-		cropHeight = originHeight / zoom
-		cropWidth = cropHeight * cropAspect
-	}
-
-	return {
-		x,
-		y,
-		width,
-		height,
-		zoom,
-		cropWidth,
-		cropHeight,
-	}
-}

package/src/content/fields/nestable/IntegrationFieldContent.ts

@@ -1,51 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import { hasContentType } from "../../utils"
-
-export const IntegrationFieldContentType = "IntegrationFieldsContent"
-
-export const isIntegrationFieldContent = (
-	u: unknown,
-): u is IntegrationFieldContent =>
-	hasContentType(u) && u.__TYPE__ === IntegrationFieldContentType
-
-type IntegrationFieldLegacy = string
-
-export const IntegrationFieldLegacy = (ctx: LegacyContentCtx) =>
-	new t.Type<
-		IntegrationFieldContent,
-		WithTypes<IntegrationFieldLegacy>,
-		unknown
-	>(
-		"IntegrationFieldLegacy",
-		isIntegrationFieldContent,
-		(u) => {
-			return pipe(
-				t.string.decode(u),
-				either.map((i) =>
-					IntegrationFieldContent.encode({
-						value: i,
-						__TYPE__: IntegrationFieldContentType,
-					}),
-				),
-			)
-		},
-
-		(i: IntegrationFieldContent) => {
-			return {
-				content: i.value,
-				types: { [ctx.keyOfType]: "IntegrationFields" },
-				keys: {},
-			}
-		},
-	)
-
-export const IntegrationFieldContent = t.strict({
-	__TYPE__: t.literal(IntegrationFieldContentType),
-	value: t.string,
-})
-
-export type IntegrationFieldContent = t.TypeOf<typeof IntegrationFieldContent>