@prismicio/types-internal 0.1.1 → 0.2.3

package/src/documents/widgets/StaticWidgetContent.ts

@@ -0,0 +1,46 @@
+import * as O from "fp-ts/Option"
+
+import { GroupContent, GroupContentType } from "./GroupContent"
+import {
+	NonEmptySimpleWidgetContent,
+	SimpleWidgetContent,
+} from "./SimpleWidgetContent"
+
+type StaticWidgetContent = SimpleWidgetContent | GroupContent
+export type NonEmptyStaticWidgetContent =
+	| NonEmptySimpleWidgetContent
+	| GroupContent
+
+const StaticWidgetContent = {
+	fromJson: (
+		prefixes: Array<string>,
+		key: string,
+		value: unknown,
+		fieldTypes: Map<string, string>,
+		fieldPositions: Map<string, number>,
+	): O.Option<StaticWidgetContent> => {
+		const prefixedKey = Array.of(prefixes, [key]).flat().join(".")
+		const type = fieldTypes.get(prefixedKey)
+		if (type === "Group") {
+			return GroupContent.fromJson(
+				prefixes,
+				key,
+				value,
+				fieldTypes,
+				fieldPositions,
+			)
+		} else if (type) {
+			return SimpleWidgetContent.from(type, value)
+		} else {
+			return O.none
+		}
+	},
+	is: (value: unknown): value is StaticWidgetContent => {
+		return (
+			SimpleWidgetContent.is(value) ||
+			GroupContentType === (value as StaticWidgetContent).__TYPE__
+		)
+	},
+}
+
+export default StaticWidgetContent

package/src/documents/widgets/UIDContent.ts

@@ -0,0 +1,18 @@
+import { Chain } from "fp-ts/Either"
+import * as t from "io-ts"
+
+export type UIDContent = {
+	__TYPE__: "UIDContent"
+	value: string
+}
+
+export const UIDContentType = "UIDContent"
+export const UIDContent = new t.Type<UIDContent, string>(
+	"UIDContent",
+	(u): u is UIDContent => (u as UIDContent)?.__TYPE__ === UIDContentType,
+	(u, c) =>
+		Chain.chain(t.string.validate(u, c), (u) => {
+			return t.success({ value: u, __TYPE__: "UIDContent" } as const)
+		}),
+	(uidContent) => uidContent.value,
+)

package/src/documents/widgets/index.ts

@@ -0,0 +1,56 @@
+import { EmptyContentType } from "./EmptyContent"
+import { GroupContentType } from "./GroupContent"
+import { NestableTypes } from "./nestable"
+import { SlicesContent, SlicesContentType } from "./slices/SlicesContent"
+import StaticWidgetContent from "./StaticWidgetContent"
+import { UIDContentType } from "./UIDContent"
+
+export * from "./EmptyContent"
+export * from "./GroupContent"
+export * as Nestable from "./nestable"
+export * from "./SimpleWidgetContent"
+export * as Slices from "./slices"
+export {
+	type NonEmptyStaticWidgetContent,
+	default as StaticWidgetContent,
+} from "./StaticWidgetContent"
+export * from "./UIDContent"
+
+export const WidgetTypes = {
+	...NestableTypes,
+	Empty: EmptyContentType,
+	UID: UIDContentType,
+	Group: GroupContentType,
+	slices: SlicesContentType,
+}
+
+export type WidgetKey = string
+export type WidgetContent = SlicesContent | StaticWidgetContent
+
+export const Widget = {
+	fromJson(
+		widgetKey: WidgetKey,
+		widgetValue: unknown,
+		widgetTypes: Map<WidgetKey, string>,
+		widgetPositions: Map<WidgetKey, number>,
+	) {
+		const fieldType = widgetTypes.get(widgetKey)
+
+		if (fieldType === "Slices") {
+			return SlicesContent.fromJson(
+				widgetKey,
+				widgetValue,
+				widgetTypes,
+				widgetPositions,
+			)
+		} else {
+			return StaticWidgetContent.fromJson(
+				[],
+				widgetKey,
+				widgetValue,
+				widgetTypes,
+				widgetPositions,
+			)
+		}
+	},
+}

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

@@ -0,0 +1,21 @@
+import { Chain } from "fp-ts/Either"
+import * as t from "io-ts"
+
+type BooleanContent = {
+	__TYPE__: "BooleanContent"
+	value: boolean
+}
+
+export const BooleanContentType = "BooleanContent"
+const BooleanContent = new t.Type<BooleanContent, boolean>(
+	"BooleanContent",
+	(u): u is BooleanContent =>
+		(u as BooleanContent)?.__TYPE__ === BooleanContentType,
+	(u, c) =>
+		Chain.chain(t.boolean.validate(u, c), (u) => {
+			return t.success({ value: u, __TYPE__: BooleanContentType } as const)
+		}),
+	(booleanContent) => t.boolean.encode(booleanContent.value),
+)
+
+export default BooleanContent

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

@@ -0,0 +1,54 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { NumberOrNull, StringOrNull } from "../../../validators"
+import { addType } from "../../../validators/function"
+
+export const EmbedContentType = "EmbedContent"
+
+type EmbedContent = t.OutputOf<typeof EmbedContentC> & {
+	all: unknown
+}
+
+const EmbedContent = new t.Type<EmbedContent, unknown, unknown>(
+	"EmbedContent",
+	(u): u is EmbedContent => (u as EmbedContent).__TYPE__ === EmbedContentType,
+	(u) => {
+		return pipe(
+			EmbedContentC.decode(u),
+			either.map((s) => ({
+				...EmbedContentC.encode(s),
+				all: u,
+			})),
+		)
+	},
+	(ec: EmbedContent) => EmbedContentC.encode(ec),
+)
+
+const EmbedContentC = addType(
+	t.exact(
+		t.intersection([
+			t.type({
+				embed_url: t.string,
+				type: t.string,
+			}),
+			t.partial({
+				version: t.union([t.string, t.number, t.null]),
+				title: StringOrNull,
+				author_name: StringOrNull,
+				author_url: StringOrNull,
+				provider_name: StringOrNull,
+				provider_url: StringOrNull,
+				cache_age: t.union([t.string, t.number, t.null]),
+				thumbnail_url: StringOrNull,
+				thumbnail_width: NumberOrNull,
+				thumbnail_height: NumberOrNull,
+				html: StringOrNull,
+			}),
+		]),
+	),
+	EmbedContentType,
+)
+
+export default EmbedContent

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

@@ -0,0 +1,45 @@
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+import * as t from "io-ts"
+
+export const FieldContentType = "FieldContent"
+type FieldContent = {
+	value: string
+	type: string
+	__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: string, 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,29 @@
+import * as t from "io-ts"
+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: nullable(t.string),
+			}),
+		]),
+	),
+	(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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,22 @@
+import { Chain } from "fp-ts/Either"
+import * as t from "io-ts"
+
+import { Link } from "./index"
+
+export type LinkContent = {
+	__TYPE__: "LinkContent"
+	value: Link
+}
+
+export const LinkContentType = "LinkContent"
+export const LinkContent = new t.Type<LinkContent, Link>(
+	"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: u, __TYPE__: LinkContentType } as const)
+		}),
+	(linkContent) => Link.encode(linkContent.value),
+)

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

@@ -0,0 +1,33 @@
+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,
+}

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

@@ -0,0 +1,8 @@
+export const SeparatorContentType = "SeparatorContent"
+export type SeparatorContent = { __TYPE__: typeof SeparatorContentType }
+export const SeparatorContent = {
+	is(value: unknown): value is SeparatorContent {
+		const asFieldContent = value as SeparatorContent
+		return asFieldContent.__TYPE__ === "SeparatorContent"
+	},
+}

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

@@ -0,0 +1,122 @@
+import * as E from "fp-ts/lib/Either"
+import * as t from "io-ts"
+
+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.string,
+		}),
+	]),
+)
+
+type Meta = t.TypeOf<typeof 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 ImageBlockType = "image"
+
+export const ImageBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: t.literal(ImageBlockType),
+			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 === ImageBlockType
+}
+
+export const EmbedBlockType = "embed"
+export const EmbedBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: t.literal(EmbedBlockType),
+			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 === EmbedBlockType
+}
+
+export const TextBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: refineType(
+				t.string,
+				`string which isn't ${ImageBlockType} ${EmbedBlockType}`,
+				(s) => s !== ImageBlockType && s !== EmbedBlockType,
+			),
+			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

@@ -0,0 +1,25 @@
+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"