@prismicio/types-internal 0.1.1 → 0.2.3

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

@@ -1,32 +1,32 @@
-import * as t from 'io-ts'
+import * as t from "io-ts"
 
-import SlicesTypes from './SlicesTypes'
+import { StringOrNull } from "../../../validators"
 import NestableWidget from "../nestable/NestableWidget"
-import { StringOrNull } from '../../../validators/StringOrNull'
+import SlicesTypes from "./SlicesTypes"
 
 const CompositeSliceConfig = t.exact(
-  t.partial({
-    label: StringOrNull
-  })
+	t.partial({
+		label: StringOrNull,
+	}),
 )
 type CompositeSliceConfig = t.TypeOf<typeof CompositeSliceConfig>
 
 const CompositeSlice = t.exact(
-  t.intersection([
-    t.type({
-      type: t.literal(SlicesTypes.Slice)
-    }),
-    t.partial({
-      fieldset: StringOrNull,
-      description: t.string,
-      icon: t.string,
-      display: t.string,
-      'non-repeat': t.record(t.string, NestableWidget),
-      repeat: t.record(t.string, NestableWidget),
-      config: CompositeSliceConfig
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(SlicesTypes.Slice),
+		}),
+		t.partial({
+			fieldset: StringOrNull,
+			description: t.string,
+			icon: t.string,
+			display: t.string,
+			"non-repeat": t.record(t.string, NestableWidget),
+			repeat: t.record(t.string, NestableWidget),
+			config: CompositeSliceConfig,
+		}),
+	]),
 )
 type CompositeSlice = t.TypeOf<typeof CompositeSlice>
 
-export default CompositeSlice
+export default CompositeSlice

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

@@ -1,15 +1,10 @@
-import * as t from 'io-ts'
+import * as t from "io-ts"
 
-import UID from '../UID'
-import NestableWidget from '../nestable/NestableWidget'
-import Group from '../Group'
+import Group from "../Group"
+import NestableWidget from "../nestable/NestableWidget"
 
-const LegacySlice = t.union([
-  UID,
-  NestableWidget,
-  Group
-])
+const LegacySlice = t.union([NestableWidget, Group])
 
 type LegacySlice = t.TypeOf<typeof LegacySlice>
 
-export default LegacySlice
+export default LegacySlice

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

@@ -1,42 +1,44 @@
-import * as t from 'io-ts'
-import { withFallback } from 'io-ts-types/lib/withFallback'
-import NestableWidget from '../nestable/NestableWidget'
-import SlicesTypes from './SlicesTypes'
+import * as t from "io-ts"
+import { withFallback } from "io-ts-types/lib/withFallback"
 
-const IMAGE_PLACEHOLDER_URL = 'https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format'
+import NestableWidget from "../nestable/NestableWidget"
+import SlicesTypes from "./SlicesTypes"
+
+const IMAGE_PLACEHOLDER_URL =
+	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"
 
 const Variation = t.exact(
-  t.intersection([
-    t.type({
-      id: t.string,
-      name: t.string,
-      description: t.string,
-      imageUrl: withFallback(t.string, IMAGE_PLACEHOLDER_URL),
-      docURL: t.string,
-      version: t.string
-    }),
-    t.partial({
-      display: t.string,
-      primary: t.record(t.string, NestableWidget),
-      items: t.record(t.string, NestableWidget)
-    })
-  ])
+	t.intersection([
+		t.type({
+			id: t.string,
+			name: t.string,
+			description: t.string,
+			imageUrl: withFallback(t.string, IMAGE_PLACEHOLDER_URL),
+			docURL: t.string,
+			version: t.string,
+		}),
+		t.partial({
+			display: t.string,
+			primary: t.record(t.string, NestableWidget),
+			items: t.record(t.string, NestableWidget),
+		}),
+	]),
 )
 
 type Variation = t.TypeOf<typeof Variation>
 
 const SharedSlice = t.exact(
-  t.intersection([
-    t.type({
-      id: t.string,
-      type: t.literal(SlicesTypes.SharedSlice),
-      name: t.string,
-      variations: t.array(Variation)
-    }),
-    t.partial({
-      description: t.string
-    })
-  ])
+	t.intersection([
+		t.type({
+			id: t.string,
+			type: t.literal(SlicesTypes.SharedSlice),
+			name: t.string,
+			variations: t.array(Variation),
+		}),
+		t.partial({
+			description: t.string,
+		}),
+	]),
 )
 
 type SharedSlice = t.TypeOf<typeof SharedSlice>

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

@@ -1,12 +1,12 @@
-import * as t from 'io-ts'
+import * as t from "io-ts"
 
-import SlicesTypes from './SlicesTypes'
+import SlicesTypes from "./SlicesTypes"
 
 const SharedSliceRef = t.exact(
-  t.type({
-    type: t.literal(SlicesTypes.SharedSlice)
-  })
+	t.type({
+		type: t.literal(SlicesTypes.SharedSlice),
+	}),
 )
 type SharedSliceRef = t.TypeOf<typeof SharedSliceRef>
 
-export default SharedSliceRef
+export default SharedSliceRef

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

@@ -1,7 +1,7 @@
-import SharedSlice from "./SharedSlice";
-import CompositeSlice from "./CompositeSlice";
-import LegacySlice from "./LegacySlice";
-import SharedSliceRef from "./SharedSliceRef";
+import type CompositeSlice from "./CompositeSlice"
+import type LegacySlice from "./LegacySlice"
+import type SharedSlice from "./SharedSlice"
+import type SharedSliceRef from "./SharedSliceRef"
 
 export type DynamicSlice = CompositeSlice | LegacySlice | SharedSliceRef
 export type StaticSlice = CompositeSlice | LegacySlice | SharedSlice

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

@@ -1,51 +1,60 @@
-import * as t from 'io-ts'
-import { StringOrNull } from '../../../validators/StringOrNull'
-import WidgetTypes from '../WidgetTypes'
-import { Format } from '../../Format'
-import LegacySlice from './LegacySlice'
-import CompositeSlice from './CompositeSlice'
-import SharedSliceRef from './SharedSliceRef'
-import SharedSlice from './SharedSlice'
-import SlicesTypes from './SlicesTypes'
+import * as t from "io-ts"
+
+import { StringOrNull } from "../../../validators"
+import { Format } from "../../Format"
+import WidgetTypes from "../WidgetTypes"
+import CompositeSlice from "./CompositeSlice"
+import LegacySlice from "./LegacySlice"
+import SharedSlice from "./SharedSlice"
+import SharedSliceRef from "./SharedSliceRef"
+import SlicesTypes from "./SlicesTypes"
 
 const SlicesLabels = t.union([
-  t.record(
-    t.string,
-    t.array(
-      t.exact(
-        t.intersection([
-          t.type({
-            name: t.string
-          }),
-          t.partial({
-            display: t.string
-          })
-        ])
-      )
-    )
-  ),
-  t.null
+	t.record(
+		t.string,
+		t.array(
+			t.exact(
+				t.intersection([
+					t.type({
+						name: t.string,
+					}),
+					t.partial({
+						display: t.string,
+					}),
+				]),
+			),
+		),
+	),
+	t.null,
 ])
 type SlicesLabels = t.TypeOf<typeof SlicesLabels>
 
 export function slicesConfigReader<F extends Format>(format: F) {
-  return t.exact(
-    t.partial({
-      label: StringOrNull,
-      labels: SlicesLabels,
-      choices: t.record(t.string, t.union([
-        LegacySlice,
-        CompositeSlice,
-        (() => {
-          switch(format) {
-            case Format.Static: return SharedSlice
-            case Format.Dynamic: return SharedSliceRef
-            default: throw new Error(`Invalid Format Exception: ${format} doesn't exist`)
-          }
-        })()
-      ]))
-    })
-  )
+	return t.exact(
+		t.partial({
+			label: StringOrNull,
+			labels: SlicesLabels,
+			choices: t.record(
+				t.string,
+				t.union([
+					LegacySlice,
+					CompositeSlice,
+					(() => {
+						switch (format) {
+							case Format.Static:
+								return SharedSlice
+							case Format.Dynamic:
+								return SharedSliceRef
+							default:
+								throw new Error(
+									`Invalid Format Exception: ${format} doesn't exist`,
+								)
+						}
+					})(),
+				]),
+			),
+		}),
+	)
 }
 export const StaticSlicesConfig = slicesConfigReader(Format.Static)
 export type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>
@@ -54,34 +63,41 @@ export const DynamicSlicesConfig = slicesConfigReader(Format.Dynamic)
 export type DynamicSlicesConfig = t.TypeOf<typeof DynamicSlicesConfig>
 
 const SlicesConfig = {
-  toStatic(config: DynamicSlicesConfig, sharedSlices: Map<string, SharedSlice>): StaticSlicesConfig {
-    const choices: {[key: string]: LegacySlice | CompositeSlice | SharedSlice } = Object.entries(config.choices || {})
-      .reduce((acc, [ref, slice]) => {
-        if(slice.type === SlicesTypes.SharedSlice) {
-          const sharedSlice = sharedSlices.get(ref)
-          if(sharedSlice) return { ...acc, [ref]: sharedSlice }
-          else return acc
-        } else {
-          return { ...acc, [ref]: slice }
-        }
-      }, {})
-  
-    return { ...config, choices } as StaticSlicesConfig
-  }
+	toStatic(
+		config: DynamicSlicesConfig,
+		sharedSlices: Map<string, SharedSlice>,
+	): StaticSlicesConfig {
+		const choices: {
+			[key: string]: LegacySlice | CompositeSlice | SharedSlice
+		} = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
+			if (slice.type === SlicesTypes.SharedSlice) {
+				const sharedSlice = sharedSlices.get(ref)
+				if (sharedSlice) return { ...acc, [ref]: sharedSlice }
+				else return acc
+			} else {
+				return { ...acc, [ref]: slice }
+			}
+		}, {})
+
+		return { ...config, choices } as StaticSlicesConfig
+	},
 }
 
 export function slicesReader<F extends Format>(format: F) {
-  return t.exact(
-    t.intersection([
-      t.type({
-        type: t.union([t.literal(WidgetTypes.Slices), t.literal(WidgetTypes.LegacySlices)])
-      }),
-      t.partial({
-        fieldset: StringOrNull,
-        config: slicesConfigReader(format)
-      })
-    ])
-  )
+	return t.exact(
+		t.intersection([
+			t.type({
+				type: t.union([
+					t.literal(WidgetTypes.Slices),
+					t.literal(WidgetTypes.LegacySlices),
+				]),
+			}),
+			t.partial({
+				fieldset: StringOrNull,
+				config: slicesConfigReader(format),
+			}),
+		]),
+	)
 }
 
 export const StaticSlices = slicesReader(Format.Static)
@@ -91,10 +107,16 @@ export const DynamicSlices = slicesReader(Format.Dynamic)
 export type DynamicSlices = t.TypeOf<typeof DynamicSlices>
 
 export const Slices = {
-  toStatic(slices: DynamicSlices, sharedSlices: Map<string, SharedSlice>): StaticSlices {
-    if(!slices.config) return slices as StaticSlices
-    else {
-      return { ...slices, config: SlicesConfig.toStatic(slices.config, sharedSlices) }
-    }
-  }
+	toStatic(
+		slices: DynamicSlices,
+		sharedSlices: Map<string, SharedSlice>,
+	): StaticSlices {
+		if (!slices.config) return slices as StaticSlices
+		else {
+			return {
+				...slices,
+				config: SlicesConfig.toStatic(slices.config, sharedSlices),
+			}
+		}
+	},
 }

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

@@ -1,6 +1,6 @@
 enum SlicesTypes {
-  Slice = 'Slice',
-  SharedSlice = 'SharedSlice'
+	Slice = "Slice",
+	SharedSlice = "SharedSlice",
 }
 
-export default SlicesTypes
+export default SlicesTypes

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

@@ -1,7 +1,7 @@
-export { default as CompositeSlice } from './CompositeSlice'
-export { default as LegacySlice } from './LegacySlice'
-export { default as SharedSlice } from './SharedSlice'
-export { default as SharedSliceRef } from './SharedSliceRef'
-export { default as SlicesTypes } from './SlicesTypes'
-export * as Slice from './Slice'
-export * as SliceZone from './Slices'
+export { default as CompositeSlice } from "./CompositeSlice"
+export { default as LegacySlice } from "./LegacySlice"
+export { default as SharedSlice } from "./SharedSlice"
+export { default as SharedSliceRef } from "./SharedSliceRef"
+export * as Slice from "./Slice"
+export * as SliceZone from "./Slices"
+export { default as SlicesTypes } from "./SlicesTypes"

package/src/documents/DocumentData.ts

@@ -0,0 +1,54 @@
+import * as O from "fp-ts/lib/Option"
+
+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>>())
+	},
+}
+
+export default DocumentData

package/src/documents/index.ts

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

package/src/documents/widgets/EmptyContent.ts

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

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

@@ -0,0 +1,96 @@
+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 from "./nestable/EmbedContent"
+import FieldContent 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
+	| EmbedContent
+	| 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, content)
+				} else {
+					return O.none
+				}
+		}
+	},
+	//TODO: rework that
+	is: (value: unknown): value is SimpleWidgetContent =>
+		SimpleWidgetContentType.includes((value as SimpleWidgetContent).__TYPE__),
+}