@prismicio/types-internal 1.5.3 → 2.0.0-alpha.0

package/src/documents/widgets/nestable/FieldContent.ts

@@ -1,53 +0,0 @@
-import { pipe } from "fp-ts/function"
-import * as O from "fp-ts/Option"
-import * as t from "io-ts"
-
-export type FieldType =
-	| "Text"
-	| "Date"
-	| "Timestamp"
-	| "Color"
-	| "Number"
-	| "Range"
-	| "Select"
-export const FieldContentType = "FieldContent"
-type FieldContent = {
-	value: string
-	type: FieldType
-	__TYPE__: typeof FieldContentType
-}
-
-//we do that instead of idiomatic .trim()
-//because we need to have the exact same behaviour than scala/java .trim()
-//in other world only trim space and not non-breaking space or tab
-function trimScalaStyle(s: string): string {
-	let startAt = 0
-	/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-	while (startAt < s.length && s[startAt]! <= " ") {
-		startAt++
-	}
-	let endAt = s.length
-	/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-	while (startAt < endAt && s[endAt - 1]! <= " ") {
-		endAt--
-	}
-	return s.substring(startAt, endAt)
-}
-
-const FieldContent = {
-	types: ["Text", "Date", "Timestamp", "Color", "Number", "Range", "Select"],
-	forType: (type: FieldType, value: unknown): O.Option<FieldContent> => {
-		return pipe(
-			O.fromEither(t.string.decode(value)),
-			O.map((r) => {
-				return {
-					value: trimScalaStyle(r),
-					type,
-					__TYPE__: "FieldContent",
-				}
-			}),
-		)
-	},
-}
-
-export default FieldContent

package/src/documents/widgets/nestable/GeoPointContent.ts

@@ -1,18 +0,0 @@
-import * as t from "io-ts"
-
-import { addType } from "../../../validators/function"
-
-export const GeoPointContentType = "GeoPointContent"
-
-export const GeoPointContent = addType(
-	t.strict({
-		position: t.strict({
-			lat: t.number,
-			lng: t.number,
-		}),
-	}),
-	GeoPointContentType,
-)
-
-export type GeoPointContent = t.TypeOf<typeof GeoPointContent>
-export type GeoPointContentO = t.OutputOf<typeof GeoPointContent>

package/src/documents/widgets/nestable/ImageContent.ts

@@ -1,51 +0,0 @@
-import * as t from "io-ts"
-
-import { NonEmptyStringOrNull, StringOrNull } from "../../../validators"
-import { addType } from "../../../validators/function"
-
-const Origin = 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: Origin,
-			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>
-
-export const ImageContentType = "ImageContent"
-export const ImageContent = addType(
-	t.intersection([
-		ImageContentView,
-		t.partial({
-			thumbnails: t.record(t.string, ImageContentView),
-		}),
-	]),
-	ImageContentType,
-)
-export type ImageContent = t.TypeOf<typeof ImageContent>
-export type ImageContentO = t.OutputOf<typeof ImageContent>

package/src/documents/widgets/nestable/IntegrationFieldsContent.ts

@@ -1,26 +0,0 @@
-import { Chain } from "fp-ts/Either"
-import * as t from "io-ts"
-
-type IntegrationFieldsContent = {
-	__TYPE__: "IntegrationFieldsContent"
-	value: string
-}
-
-export const IntegrationFieldsContentType = "IntegrationFieldsContent"
-const IntegrationFieldsContent = new t.Type<IntegrationFieldsContent>(
-	"IntegrationFieldsContent",
-	(u): u is IntegrationFieldsContent =>
-		(u as IntegrationFieldsContent)?.__TYPE__ === IntegrationFieldsContentType,
-	(u, c) =>
-		Chain.chain(t.string.validate(u, c), (u) => {
-			return t.success({
-				value: u,
-				__TYPE__: IntegrationFieldsContentType,
-			} as const)
-		}),
-	() => {
-		throw new Error("Not implemented - Not used - Not relevant")
-	},
-)
-
-export default IntegrationFieldsContent

package/src/documents/widgets/nestable/Link/DocumentLink.ts

@@ -1,18 +0,0 @@
-import * as t from "io-ts"
-
-import { NonEmptyString } from "../../../../validators"
-import { addType } from "../../../../validators/function"
-
-export const DocumentLinkType = "DocumentLink"
-
-export const DocumentLink = addType(
-	t.strict({ id: NonEmptyString }),
-	DocumentLinkType,
-)
-
-export type DocumentLink = t.TypeOf<typeof DocumentLink>
-export type DocumentLinkO = t.OutputOf<typeof DocumentLink>
-
-export function isDocumentLink(u: unknown): u is DocumentLinkO {
-	return (u as DocumentLinkO).__TYPE__ === DocumentLinkType
-}

package/src/documents/widgets/nestable/Link/ExternalLink.ts

@@ -1,31 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../../validators"
-import { addType, nullable } from "../../../../validators/function"
-
-export const ExternalLinkType = "ExternalLink"
-export const ExternalLink = addType(
-	t.exact(
-		t.intersection([
-			t.type({
-				url: t.string,
-			}),
-			t.partial({
-				kind: t.literal("web"),
-				target: StringOrNull,
-				preview: nullable(
-					t.partial({
-						title: t.string,
-					}),
-				),
-			}),
-		]),
-	),
-	ExternalLinkType,
-)
-
-export type ExternalLink = t.TypeOf<typeof ExternalLink>
-export type ExternalLinkO = t.OutputOf<typeof ExternalLink>
-export function isExternalLink(u: unknown): u is ExternalLinkO {
-	return (u as ExternalLinkO).__TYPE__ === ExternalLinkType
-}

package/src/documents/widgets/nestable/Link/FileLink.ts

@@ -1,30 +0,0 @@
-import * as t from "io-ts"
-import { withFallback } from "io-ts-types"
-import { mapOutput } from "io-ts-types/lib/mapOutput"
-
-import { nullable } from "../../../../validators/function"
-
-export const FileLinkType = "FileLink"
-export const FileLink = mapOutput(
-	t.exact(
-		t.intersection([
-			t.type({
-				id: t.string,
-				url: t.string,
-				name: t.string,
-				kind: t.string,
-			}),
-			t.partial({
-				date: nullable(t.string),
-				size: withFallback(t.string, "0"),
-			}),
-		]),
-	),
-	(o) => ({ ...o, size: o.size || "0", __TYPE__: FileLinkType } as const),
-)
-
-export type FileLink = t.TypeOf<typeof FileLink>
-export type FileLinkO = t.OutputOf<typeof FileLink>
-export function isFileLink(u: unknown): u is FileLinkO {
-	return (u as FileLinkO).__TYPE__ === FileLinkType
-}

package/src/documents/widgets/nestable/Link/ImageLink.ts

@@ -1,31 +0,0 @@
-import * as t from "io-ts"
-
-import { StringOrNull } from "../../../../validators"
-import { addType } from "../../../../validators/function"
-
-export const ImageLinkType = "ImageLink"
-export const ImageLink = addType(
-	t.exact(
-		t.intersection([
-			t.type({
-				id: t.string,
-				url: t.string,
-				height: t.string,
-				width: t.string,
-				size: t.string,
-				name: t.string,
-				kind: t.string,
-			}),
-			t.partial({
-				date: StringOrNull,
-			}),
-		]),
-	),
-	ImageLinkType,
-)
-
-export type ImageLink = t.TypeOf<typeof ImageLink>
-export type ImageLinkO = t.OutputOf<typeof ImageLink>
-export function isImageLink(u: unknown): u is ImageLinkO {
-	return (u as ImageLinkO).__TYPE__ === ImageLinkType
-}

package/src/documents/widgets/nestable/Link/LinkContent.ts

@@ -1,25 +0,0 @@
-import { Chain } from "fp-ts/Either"
-import * as t from "io-ts"
-
-import { Link, LinkO } from "./index"
-
-export type LinkContent = {
-	__TYPE__: "LinkContent"
-	value: LinkO
-}
-
-export const LinkContentType = "LinkContent"
-export const LinkContent = new t.Type<LinkContent, LinkO>(
-	"LinkContent",
-	(u): u is LinkContent => {
-		return Link.is((u as LinkContent)?.value)
-	},
-	(u, c) =>
-		Chain.chain(Link.validate(u, c), (u) => {
-			return t.success({
-				value: Link.encode(u),
-				__TYPE__: LinkContentType,
-			} as const)
-		}),
-	(linkContent) => Link.encode(linkContent.value),
-)

package/src/documents/widgets/nestable/Link/index.ts

@@ -1,35 +0,0 @@
-import * as t from "io-ts"
-
-import { DocumentLink, DocumentLinkType, isDocumentLink } from "./DocumentLink"
-import { ExternalLink, ExternalLinkType, isExternalLink } from "./ExternalLink"
-import { FileLink, FileLinkType, isFileLink } from "./FileLink"
-import { ImageLink, ImageLinkType, isImageLink } from "./ImageLink"
-import { LinkContentType } from "./LinkContent"
-
-export const Link = t.union([ImageLink, FileLink, DocumentLink, ExternalLink])
-export type Link = t.TypeOf<typeof Link>
-export type LinkO = t.OutputOf<typeof Link>
-
-export { type DocumentLinkO, DocumentLink } from "./DocumentLink"
-export { type ExternalLinkO, ExternalLink } from "./ExternalLink"
-export { type FileLinkO, FileLink } from "./FileLink"
-export { type ImageLinkO, ImageLink } from "./ImageLink"
-export { LinkContent } from "./LinkContent"
-
-export const BROKEN_CUSTOM_TYPE = "broken_type"
-
-export const is = {
-	documentLink: isDocumentLink,
-	fileLink: isFileLink,
-	externalLink: isExternalLink,
-	imageLink: isImageLink,
-}
-export const LinksTypes = {
-	DocumentLink: DocumentLinkType,
-	FileLink: FileLinkType,
-	ExternalLink: ExternalLinkType,
-	ImageLink: ImageLinkType,
-	LinkContent: LinkContentType,
-} as const
-
-export type LinksTypes = typeof LinksTypes[keyof typeof LinksTypes]

package/src/documents/widgets/nestable/SeparatorContent.ts

@@ -1,13 +0,0 @@
-import * as t from "io-ts"
-
-export const SeparatorContentType = "SeparatorContent"
-export type SeparatorContent = { __TYPE__: typeof SeparatorContentType }
-export const SeparatorContent = {
-	codec: t.strict({
-		__TYPE__: t.literal(SeparatorContentType),
-	}),
-	is(value: unknown): value is SeparatorContent {
-		const asFieldContent = value as SeparatorContent
-		return asFieldContent.__TYPE__ === "SeparatorContent"
-	},
-}

package/src/documents/widgets/nestable/StructuredTextContent/Block.ts

@@ -1,126 +0,0 @@
-import * as E from "fp-ts/lib/Either"
-import * as t from "io-ts"
-
-import {
-	RichTextNodeType,
-	RichTextNodeTypeCodec,
-} from "../../../../customtypes/widgets/nestable"
-import { StringOrNull } from "../../../../validators"
-import { nullable, refineType } from "../../../../validators/function"
-import { EmbedContent } from "../EmbedContent"
-import { ImageContentView } from "../ImageContent"
-import { Link } from "../Link"
-
-export const Meta = t.exact(
-	t.intersection([
-		t.partial({
-			data: t.unknown,
-		}),
-		t.type({
-			start: t.number,
-			end: t.number,
-			type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
-		}),
-	]),
-)
-export type Meta = t.TypeOf<typeof Meta>
-
-// export alias for code clarity
-export const Span = Meta
-export type Span = Meta
-
-export const ValidatedMetas = new t.Type<Meta[], Meta[], unknown>(
-	"ValidatedMetas",
-	(metas): metas is Meta[] => Array.isArray(metas) && metas.every(Meta.is),
-	(metas: unknown, c) => {
-		if (Array.isArray(metas)) {
-			const res = metas
-				.reduce<Array<Meta>>((acc, maybeMeta) => {
-					const maybeDecodedMeta = Meta.decode(maybeMeta)
-					if (E.isRight(maybeDecodedMeta)) {
-						const meta = maybeDecodedMeta.right
-						// if it's an hyperlink it should have data validated as link otherwise we don't care and keep the meta
-						if (
-							(meta.data &&
-								meta.type === "hyperlink" &&
-								E.isRight(Link.validate(meta.data, c))) ||
-							meta.type !== "hyperlink"
-						) {
-							return [...acc, meta]
-						}
-					}
-					return acc
-				}, [])
-				.sort((m1: Meta, m2: Meta) => m1.start - m2.start)
-			return t.success(res)
-		} else return t.failure(metas, c)
-	},
-	(m) => t.array(Meta).encode(m),
-)
-
-export const ImageBlock = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(RichTextNodeType.image),
-			data: t.intersection([
-				ImageContentView,
-				t.partial({
-					linkTo: nullable(Link),
-				}),
-			]),
-		}),
-		t.partial({
-			label: StringOrNull,
-			direction: StringOrNull,
-		}),
-	]),
-)
-export type ImageBlock = t.TypeOf<typeof ImageBlock>
-export function checkImageBlock(block: Block): block is ImageBlock {
-	return block.type === RichTextNodeType.image
-}
-
-export const EmbedBlock = t.exact(
-	t.intersection([
-		t.type({
-			type: t.literal(RichTextNodeType.embed),
-			data: EmbedContent,
-		}),
-		t.partial({
-			label: StringOrNull,
-			direction: StringOrNull,
-		}),
-	]),
-)
-export type EmbedBlock = t.TypeOf<typeof EmbedBlock>
-export function checkEmbedBlock(block: Block): block is EmbedBlock {
-	return block.type === RichTextNodeType.embed
-}
-
-export const TextBlock = t.exact(
-	t.intersection([
-		t.type({
-			type: refineType(
-				RichTextNodeTypeCodec,
-				`string which isn't ${RichTextNodeType.image} ${RichTextNodeType.embed}`,
-				(s) => s !== RichTextNodeType.image && s !== RichTextNodeType.embed,
-			),
-			content: t.intersection([
-				t.type({
-					text: t.string,
-				}),
-				t.partial({
-					spans: ValidatedMetas,
-				}),
-			]),
-		}),
-		t.partial({
-			label: t.string,
-			direction: t.string,
-		}),
-	]),
-)
-export type TextBlock = t.TypeOf<typeof TextBlock>
-
-export const Block = t.union([ImageBlock, EmbedBlock, TextBlock])
-export type Block = t.TypeOf<typeof Block>

package/src/documents/widgets/nestable/StructuredTextContent/index.ts

@@ -1,25 +0,0 @@
-import { Chain } from "fp-ts/Either"
-import * as t from "io-ts"
-
-import { Block } from "./Block"
-
-export const StructuredTextContentType = "StructuredTextContent"
-export type StructuredTextContent = {
-	value: Block[]
-	__TYPE__: typeof StructuredTextContentType
-}
-
-export const StructuredTextContent = new t.Type<StructuredTextContent, string>(
-	StructuredTextContentType,
-	(u): u is StructuredTextContent =>
-		(u as StructuredTextContent)?.__TYPE__ === StructuredTextContentType,
-	(u, c) =>
-		Chain.chain(t.array(Block).validate(u, c), (u) => {
-			return t.success({ value: u, __TYPE__: StructuredTextContentType })
-		}),
-	() => {
-		throw new Error("NotImplementedError: Not relevant method")
-	},
-)
-
-export * as Blocks from "./Block"

package/src/documents/widgets/nestable/index.ts

@@ -1,35 +0,0 @@
-import { BooleanContentType } from "./BooleanContent"
-import { EmbedContentType } from "./EmbedContent"
-import { FieldContentType } from "./FieldContent"
-import { GeoPointContentType } from "./GeoPointContent"
-import { ImageContentType } from "./ImageContent"
-import { IntegrationFieldsContentType } from "./IntegrationFieldsContent"
-import { LinksTypes } from "./Link"
-import { SeparatorContentType } from "./SeparatorContent"
-import { StructuredTextContentType } from "./StructuredTextContent"
-
-export { default as BooleanContent } from "./BooleanContent"
-export * from "./EmbedContent"
-export { default as FieldContent } from "./FieldContent"
-export { type GeoPointContentO, GeoPointContent } from "./GeoPointContent"
-export {
-	type ImageContentO,
-	ImageContent,
-	ImageContentView,
-} from "./ImageContent"
-export { default as IntegrationFieldsContent } from "./IntegrationFieldsContent"
-export * as Links from "./Link"
-export * from "./SeparatorContent"
-export * from "./StructuredTextContent"
-
-export const NestableTypes = {
-	Links: LinksTypes,
-	StructuredText: StructuredTextContentType,
-	Boolean: BooleanContentType,
-	Embed: EmbedContentType,
-	Field: FieldContentType,
-	GeoPoint: GeoPointContentType,
-	Image: ImageContentType,
-	IntegrationFields: IntegrationFieldsContentType,
-	Separator: SeparatorContentType,
-} as const

package/src/documents/widgets/slices/CompositeSliceContent.ts

@@ -1,77 +0,0 @@
-import { isRight } from "fp-ts/Either"
-import * as O from "fp-ts/Option"
-import * as t from "io-ts"
-
-import type { GroupItemContent } from "../GroupContent"
-import { GroupContent, SimpleWidgetContent } from "../index"
-
-export const CompositeSliceContentType = "CompositeSliceContent"
-export type CompositeSliceContent = {
-	repeat: GroupItemContent[]
-	nonRepeat: { [key: string]: SimpleWidgetContent }
-	__TYPE__: typeof CompositeSliceContentType
-}
-
-const codec = t.exact(
-	t.partial({
-		repeat: t.array(t.unknown),
-		"non-repeat": t.UnknownRecord,
-	}),
-)
-
-export const CompositeSliceContent = {
-	fromJson: (
-		prefixes: Array<string>,
-		key: string,
-		value: unknown,
-		fieldTypes: Map<string, string>,
-		fieldPositions: Map<string, number>,
-	): O.Option<CompositeSliceContent> => {
-		const prefixedRepeatKey = Array.of(prefixes, [key, "repeat"])
-			.flat()
-			.join(".")
-
-		const decodedValue = codec.decode(value)
-		if (isRight(decodedValue)) {
-			const repeatObj = decodedValue.right.repeat
-			const nonRepeatObj = decodedValue.right["non-repeat"] ?? {}
-			const groupItemsContentsRepeat = GroupContent.itemsContentsFromJson(
-				prefixedRepeatKey,
-				repeatObj,
-				fieldTypes,
-				fieldPositions,
-			)
-			const sortedFields = Object.entries(nonRepeatObj).sort(([k1], [k2]) => {
-				const p1 =
-					fieldPositions.get(
-						`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`,
-					) ?? 10000
-				const p2 =
-					fieldPositions.get(
-						`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`,
-					) ?? 10000
-				return p1 - p2
-			})
-
-			const nonRepeat = sortedFields.reduce((acc, [k, v]) => {
-				const kp = Array.of(prefixes, [key, "non-repeat", k]).flat().join(".")
-				const kind = fieldTypes.get(kp)
-				if (kind) {
-					const mWidgetContent = SimpleWidgetContent.from(kind, v)
-					if (O.isSome(mWidgetContent)) {
-						acc[k] = mWidgetContent.value
-					}
-				}
-				return acc
-			}, {} as Record<string, SimpleWidgetContent>)
-
-			return O.some({
-				repeat: groupItemsContentsRepeat,
-				nonRepeat,
-				__TYPE__: "CompositeSliceContent",
-			})
-		} else {
-			return O.none
-		}
-	},
-}