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

package/src/customtypes/widgets/slices/Slices.ts

@@ -1,13 +1,14 @@
 import * as t from "io-ts"
 
-import { WidgetKey } from "../../../documents/widgets"
+import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
-import { WidgetTypes } from "../WidgetTypes"
 import CompositeSlice from "./CompositeSlice"
 import LegacySlice from "./LegacySlice"
 import { SharedSlice } from "./SharedSlice"
 import SharedSliceRef from "./SharedSliceRef"
-import { SlicesTypes } from "./SlicesTypes"
+
+export const LegacySlicesFieldType = "Choice"
+export const SlicesFieldType = "Slices"
 
 export const SlicesLabels = t.union([
 	t.record(
@@ -57,7 +58,7 @@ const SlicesConfig = {
 		const choices: {
 			[key: string]: LegacySlice | CompositeSlice | SharedSlice
 		} = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
-			if (slice.type === SlicesTypes.SharedSlice) {
+			if (slice.type === "SharedSlice") {
 				const sharedSlice = sharedSlices.get(ref)
 				if (sharedSlice) return { ...acc, [ref]: sharedSlice }
 				else return acc
@@ -77,8 +78,8 @@ export function slicesReader<
 		t.intersection([
 			t.type({
 				type: t.union([
-					t.literal(WidgetTypes.Slices),
-					t.literal(WidgetTypes.LegacySlices),
+					t.literal(SlicesFieldType),
+					t.literal(LegacySlicesFieldType),
 				]),
 			}),
 			t.partial({

package/src/customtypes/widgets/slices/SlicesTypes.ts

@@ -1,6 +1,11 @@
-export const SlicesTypes = {
-	Slice: "Slice",
-	SharedSlice: "SharedSlice",
-} as const
+import * as t from "io-ts"
 
-export type SlicesTypes = typeof SlicesTypes[keyof typeof SlicesTypes]
+import { CompositeSliceType } from "./CompositeSlice"
+import { SharedSliceType } from "./SharedSlice"
+
+export const SlicesTypes = t.keyof({
+	[CompositeSliceType]: null,
+	[SharedSliceType]: null,
+})
+
+export type SlicesTypes = t.TypeOf<typeof SlicesTypes>

package/src/utils/Objects.ts

@@ -21,3 +21,15 @@ export function zipObjects<A, B = A>(
 export function isNotEmpty<A extends object>(obj: A): boolean {
 	return Boolean(Object.keys(obj).length)
 }
+
+export function withOptionals<T extends object>(
+	object: T,
+	optionals: Array<[keyof T, T[keyof T] | null | undefined]>,
+): T {
+	return {
+		...object,
+		...optionals.reduce((acc, [key, value]) => {
+			return value ? { ...acc, [key]: value } : acc
+		}, {}),
+	}
+}

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

@@ -1,25 +0,0 @@
-import * as t from "io-ts"
-
-import { FieldContentType as type } from "../../../documents/widgets/nestable/FieldContent"
-import TrimmedString from "../../../validators/TrimmedString"
-
-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.strict({
-	type: FieldType,
-	value: TrimmedString,
-	__TYPE__: t.literal(type),
-})
-
-export type FieldContent = t.TypeOf<typeof FieldContent>
-export const FieldContentType = type

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

@@ -1,32 +0,0 @@
-import * as t from "io-ts"
-
-import {
-	Blocks,
-	StructuredTextContentType as type,
-} from "../../../documents/widgets/nestable/StructuredTextContent"
-import {
-	Block as b,
-	EmbedBlock as eBlock,
-	ImageBlock as iBlock,
-	TextBlock as tBlock,
-} from "../../../documents/widgets/nestable/StructuredTextContent/Block"
-
-export const RichTextContent = t.strict({
-	__TYPE__: t.literal(type),
-	value: t.array(Blocks.Block),
-})
-
-export type RichTextContent = t.TypeOf<typeof RichTextContent>
-export const RichTextContentType = type
-
-export const TextBlock = tBlock
-export type TextBlock = tBlock
-
-export const ImageBlock = iBlock
-export type ImageBlock = iBlock
-
-export const EmbedBlock = eBlock
-export type EmbedBlock = eBlock
-
-export const Block = b
-export type Block = b

package/src/content/fields/slices/CompositeSliceContent.ts

@@ -1,14 +0,0 @@
-import * as t from "io-ts"
-
-import { CompositeSliceContentType as type } from "../../../documents/widgets/slices"
-import { NestableContent } from "../nestable"
-import { RepeatableWidgets } from "./RepeatableContent"
-
-export const CompositeSliceContent = t.strict({
-	__TYPE__: t.literal(type),
-	nonRepeat: t.record(t.string, NestableContent),
-	repeat: RepeatableWidgets,
-})
-
-export type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>
-export const CompositeSliceContentType = type

package/src/content/fields/slices/SharedSliceContent.ts

@@ -1,14 +0,0 @@
-import * as t from "io-ts"
-
-import { SharedSliceContentType as type } from "../../../documents/widgets/slices"
-import { NestableContent } from "../nestable"
-import { RepeatableWidgets } from "./RepeatableContent"
-
-export const SharedSliceContent = t.strict({
-	__TYPE__: t.literal(type),
-	variation: t.string,
-	primary: t.record(t.string, NestableContent),
-	items: RepeatableWidgets,
-})
-export type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>
-export const SharedSliceContentType = type

package/src/content/fields/slices/SimpleSliceContent.ts

@@ -1,7 +0,0 @@
-import * as t from "io-ts"
-
-import { GroupContent } from "../GroupContent"
-import { NestableContent } from "../nestable"
-
-export const SimpleSliceContent = t.union([NestableContent, GroupContent])
-export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>

package/src/customtypes/widgets/WidgetTypes.ts

@@ -1,24 +0,0 @@
-export const WidgetTypes = {
-	Text: "Text",
-	RichText: "StructuredText",
-	Color: "Color",
-	Image: "Image",
-	Date: "Date",
-	Timestamp: "Timestamp",
-	Number: "Number",
-	Range: "Range",
-	Select: "Select",
-	Link: "Link",
-	Embed: "Embed",
-	GeoPoint: "GeoPoint",
-	Separator: "Separator",
-	UID: "UID",
-	BooleanField: "Boolean",
-	IntegrationField: "IntegrationFields",
-	Group: "Group",
-	Slices: "Slices",
-	// Legacy type for slices
-	LegacySlices: "Choice",
-} as const
-
-export type WidgetTypes = typeof WidgetTypes[keyof typeof WidgetTypes]

package/src/documents/DocumentData.ts

@@ -1,112 +0,0 @@
-import { isRight } from "fp-ts/lib/Either"
-import * as O from "fp-ts/lib/Option"
-import * as t from "io-ts"
-
-import { type WidgetContent, type WidgetKey, Widget } from "./widgets"
-
-type DocumentData = Map<WidgetKey, O.Option<WidgetContent>>
-function computeWidget(
-	key: WidgetKey,
-	widgets: Map<WidgetKey, unknown>,
-	widgetTypes: Map<WidgetKey, string>,
-	widgetPositions: Map<WidgetKey, number>,
-): O.Option<WidgetContent> {
-	const widget = widgets.get(key)
-	if (widget === undefined) {
-		return O.none
-	}
-	return Widget.fromJson(key, widget, widgetTypes, widgetPositions)
-}
-
-const DocumentData = {
-	getWidget(
-		key: WidgetKey,
-		widgets: Map<WidgetKey, unknown>,
-		widgetTypes: Map<WidgetKey, string>,
-		widgetPositions: Map<WidgetKey, number>,
-		parsed: Map<string, O.Option<WidgetContent>>,
-	): O.Option<WidgetContent> {
-		const widget = parsed.get(key)
-		if (widget === undefined) {
-			return computeWidget(key, widgets, widgetTypes, widgetPositions)
-		}
-		return widget
-	},
-
-	fromJson(
-		widgets: Map<WidgetKey, unknown>,
-		widgetTypes: Map<WidgetKey, string>,
-		widgetPositions: Map<WidgetKey, number>,
-	): DocumentData {
-		return Array.from(widgets.keys()).reduce<
-			Map<WidgetKey, O.Option<WidgetContent>>
-		>((acc, widgetKey) => {
-			const parsedWidget = this.getWidget(
-				widgetKey,
-				widgets,
-				widgetTypes,
-				widgetPositions,
-				acc,
-			)
-			return new Map([...Array.from(acc.entries()), [widgetKey, parsedWidget]])
-		}, new Map<WidgetKey, O.Option<WidgetContent>>())
-	},
-
-	partitionData(data: { [p: string]: unknown }): {
-		types: Map<string, string>
-		positions: Map<string, number>
-		widgets: Map<WidgetKey, unknown>
-		slugs: ReadonlyArray<string>
-		uid: string | undefined
-	} {
-		const fields: [string, unknown][] = Object.entries(data)
-
-		const { types, positions, widgets } = fields.reduce(
-			(acc, [k, v]) => {
-				if (k.endsWith("_TYPE")) {
-					const decodedValue = t.string.decode(v)
-					if (isRight(decodedValue)) {
-						return {
-							...acc,
-							types: acc.types.set(
-								k.substring(0, k.length - 5),
-								decodedValue.right,
-							),
-						}
-					}
-				}
-				if (k.endsWith("_POSITION") && typeof v === "number") {
-					return {
-						...acc,
-						positions: acc.positions.set(k.substring(0, k.length - 9), v),
-					}
-				}
-				if (!k.endsWith("_POSITION") && !k.endsWith("_TYPE")) {
-					return {
-						...acc,
-						widgets: acc.widgets.set(k, v),
-					}
-				}
-				return acc
-			},
-			{
-				types: new Map<string, string>(),
-				positions: new Map<string, number>(),
-				widgets: new Map<string, unknown>(),
-			},
-		)
-
-		const slugs = (data["slugs_INTERNAL"] as string[]) || []
-		const uid = data["uid"] as string | undefined
-
-		return {
-			widgets,
-			types,
-			positions,
-			uid,
-			slugs,
-		}
-	},
-}
-
-export default DocumentData

package/src/documents/index.ts

@@ -1,2 +0,0 @@
-export { default as DocumentData } from "./DocumentData"
-export * as Widgets from "./widgets"

package/src/documents/widgets/EmptyContent.ts

@@ -1,8 +0,0 @@
-export const EmptyContentType = "EmptyContent"
-export type EmptyContent = { type: string; __TYPE__: typeof EmptyContentType }
-
-export const EmptyContent = {
-	is: (value: unknown): value is EmptyContent => {
-		return (value as EmptyContent).__TYPE__ === EmptyContentType
-	},
-}

package/src/documents/widgets/GroupContent.ts

@@ -1,91 +0,0 @@
-import * as A from "fp-ts/Array"
-import * as O from "fp-ts/Option"
-import * as t from "io-ts"
-
-import { SimpleWidgetContent } from "./SimpleWidgetContent"
-
-export const GroupItemContentType = "GroupItemContent"
-export interface GroupItemContent {
-	__TYPE__: typeof GroupItemContentType
-	value: Array<[string, SimpleWidgetContent]>
-}
-
-export const GroupContentType = "GroupContentType"
-export interface GroupContent {
-	__TYPE__: typeof GroupContentType
-	value: GroupItemContent[]
-}
-
-export const GroupContent = Object.freeze({
-	itemsContentsFromJson: (
-		prefixedKey: string,
-		jsItems: Array<unknown> | undefined,
-		fieldTypes: Map<string, string>,
-		fieldPositions: Map<string, number>,
-	): Array<GroupItemContent> => {
-		if (jsItems) {
-			return jsItems.map((jsItem) => {
-				if (typeof jsItem === "object" && jsItem !== null) {
-					const sorted = Object.entries(jsItem).sort(([k1], [k2]) => {
-						const p1 = fieldPositions.get(`${prefixedKey}.${k1}`) ?? 10000
-						const p2 = fieldPositions.get(`${prefixedKey}.${k2}`) ?? 10000
-						return p1 - p2
-					})
-
-					const w: O.Option<[string, SimpleWidgetContent]>[] = sorted.map(
-						([k, v]) => {
-							const kind = fieldTypes.get(`${prefixedKey}.${k}`)
-							if (kind) {
-								return O.map<
-									SimpleWidgetContent,
-									[string, SimpleWidgetContent]
-								>((content) => {
-									return [k, content]
-								})(SimpleWidgetContent.from(kind, v))
-							} else {
-								return O.none
-							}
-						},
-					)
-
-					return {
-						__TYPE__: "GroupItemContent",
-						value: A.compact(w),
-					}
-				} else {
-					return {
-						__TYPE__: "GroupItemContent",
-						value: [],
-					}
-				}
-			})
-		} else {
-			return []
-		}
-	},
-
-	fromJson: (
-		prefixes: Array<string>,
-		key: string,
-		value: unknown,
-		fieldTypes: Map<string, string>,
-		fieldPositions: Map<string, number>,
-	): O.Option<GroupContent> => {
-		const prefixedKey = Array.of(prefixes, [key]).flat().join(".")
-
-		const maybeJsItems: O.Option<Array<unknown>> = O.fromEither(
-			t.array(t.unknown).decode(value),
-		)
-		return O.map((items: Array<unknown>) => {
-			return {
-				value: GroupContent.itemsContentsFromJson(
-					prefixedKey,
-					items,
-					fieldTypes,
-					fieldPositions,
-				),
-				__TYPE__: GroupContentType,
-			} as const
-		})(maybeJsItems)
-	},
-})

package/src/documents/widgets/SimpleWidgetContent.ts

@@ -1,96 +0,0 @@
-import { pipe } from "fp-ts/function"
-import * as O from "fp-ts/Option"
-import * as t from "io-ts"
-
-import type { EmptyContent } from "./EmptyContent"
-import BooleanContent from "./nestable/BooleanContent"
-import { EmbedContent, EmbedContentO } from "./nestable/EmbedContent"
-import FieldContent, { FieldType } from "./nestable/FieldContent"
-import { GeoPointContent, GeoPointContentO } from "./nestable/GeoPointContent"
-import { ImageContent, ImageContentO } from "./nestable/ImageContent"
-import IntegrationFieldsContent from "./nestable/IntegrationFieldsContent"
-import { LinkContent } from "./nestable/Link"
-import type { SeparatorContent } from "./nestable/SeparatorContent"
-import { StructuredTextContent } from "./nestable/StructuredTextContent"
-import { UIDContent } from "./UIDContent"
-
-//TODO: rework that using import such as EmptyContentType
-export const SimpleWidgetContentType = [
-	"EmptyContent",
-	"ImageContent",
-	"GeoPointContent",
-	"EmbedContent",
-	"BooleanContent",
-	"IntegrationFieldsContent",
-	"StructuredTextContent",
-	"LinkContent",
-	"UIDContent",
-	"SeparatorContent",
-	"FieldContent",
-]
-
-export type NonEmptySimpleWidgetContent =
-	| IntegrationFieldsContent
-	| StructuredTextContent
-	| ImageContentO
-	| GeoPointContentO
-	| EmbedContentO
-	| LinkContent
-	| UIDContent
-	| SeparatorContent
-	| FieldContent
-	| BooleanContent
-
-export type SimpleWidgetContent = NonEmptySimpleWidgetContent | EmptyContent
-
-export function is(value: unknown): value is SimpleWidgetContent {
-	const asSwc = value as SimpleWidgetContent
-	return SimpleWidgetContentType.includes(asSwc.__TYPE__)
-}
-const valueNullCodec = t.type({
-	value: t.null,
-})
-export const SimpleWidgetContent = {
-	from: (type: string, content: unknown): O.Option<SimpleWidgetContent> => {
-		if (content === null || valueNullCodec.is(content)) {
-			const result: EmptyContent = { type: type, __TYPE__: "EmptyContent" }
-			return O.some(result)
-		}
-
-		switch (type) {
-			case "StructuredText":
-				return O.fromEither(StructuredTextContent.decode(content))
-			case "IntegrationFields":
-				return O.fromEither(IntegrationFieldsContent.decode(content))
-			case "Image":
-				return pipe(
-					O.fromEither(ImageContent.decode(content)),
-					O.map((imageContent) => ImageContent.encode(imageContent)),
-				)
-			case "GeoPoint":
-				return pipe(
-					O.fromEither(GeoPointContent.decode(content)),
-					O.map((geopointContent) => GeoPointContent.encode(geopointContent)),
-				)
-			case "Embed":
-				return O.fromEither(EmbedContent.decode(content))
-			case "Link":
-				return O.fromEither(LinkContent.decode(content))
-			case "UID":
-				return O.fromEither(UIDContent.decode(content))
-			case "Separator":
-				return O.some({ __TYPE__: "SeparatorContent" })
-			case "Boolean":
-				return O.fromEither(BooleanContent.decode(content))
-			default:
-				if (FieldContent.types.includes(type)) {
-					return FieldContent.forType(type as FieldType, content)
-				} else {
-					return O.none
-				}
-		}
-	},
-	//TODO: rework that
-	is: (value: unknown): value is SimpleWidgetContent =>
-		SimpleWidgetContentType.includes((value as SimpleWidgetContent).__TYPE__),
-}

package/src/documents/widgets/StaticWidgetContent.ts

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

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

@@ -1,70 +0,0 @@
-import * as t from "io-ts"
-
-import { refineType } from "../../validators/function"
-import { EmptyContentType } from "./EmptyContent"
-import { GroupContentType } from "./GroupContent"
-import { NestableTypes } from "./nestable"
-import { SlicesContent, SlicesContentType } from "./slices"
-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,
-} as const
-
-export type WidgetTypes = typeof WidgetTypes[keyof typeof WidgetTypes]
-
-const widgetKeyRegex = new RegExp("^[^<>]+$")
-
-export const WidgetKey = refineType(
-	t.string,
-	"WidgetKey",
-	(s: string) => s.length === 0 || widgetKeyRegex.test(s),
-)
-
-export type WidgetKey = t.TypeOf<typeof WidgetKey>
-
-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

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