@prismicio/types-internal 0.2.6 → 0.2.9

package/lib/customtypes/widgets/slices/Slices.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = void 0;
+exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../validators");
-const Format_1 = require("../../Format");
 const WidgetTypes_1 = (0, tslib_1.__importDefault)(require("../WidgetTypes"));
 const CompositeSlice_1 = (0, tslib_1.__importDefault)(require("./CompositeSlice"));
 const LegacySlice_1 = (0, tslib_1.__importDefault)(require("./LegacySlice"));
 const SharedSlice_1 = require("./SharedSlice");
 const SharedSliceRef_1 = (0, tslib_1.__importDefault)(require("./SharedSliceRef"));
 const SlicesTypes_1 = (0, tslib_1.__importDefault)(require("./SlicesTypes"));
-const SlicesLabels = t.union([
+exports.SlicesLabels = t.union([
     t.record(t.string, t.array(t.exact(t.intersection([
         t.type({
             name: t.string,
@@ -22,29 +21,16 @@ const SlicesLabels = t.union([
     ])))),
     t.null,
 ]);
-function slicesConfigReader(format) {
+function slicesConfigReader(codec) {
     return t.exact(t.partial({
         label: validators_1.StringOrNull,
-        labels: SlicesLabels,
-        choices: t.record(t.string, t.union([
-            LegacySlice_1.default,
-            CompositeSlice_1.default,
-            (() => {
-                switch (format) {
-                    case Format_1.Format.Static:
-                        return SharedSlice_1.SharedSlice;
-                    case Format_1.Format.Dynamic:
-                        return SharedSliceRef_1.default;
-                    default:
-                        throw new Error(`Invalid Format Exception: ${format} doesn't exist`);
-                }
-            })(),
-        ])),
+        labels: exports.SlicesLabels,
+        choices: t.record(t.string, t.union([LegacySlice_1.default, CompositeSlice_1.default, codec])),
     }));
 }
 exports.slicesConfigReader = slicesConfigReader;
-exports.StaticSlicesConfig = slicesConfigReader(Format_1.Format.Static);
-exports.DynamicSlicesConfig = slicesConfigReader(Format_1.Format.Dynamic);
+exports.StaticSlicesConfig = slicesConfigReader(SharedSlice_1.SharedSlice);
+exports.DynamicSlicesConfig = slicesConfigReader(SharedSliceRef_1.default);
 const SlicesConfig = {
     toStatic(config, sharedSlices) {
         const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
@@ -62,7 +48,7 @@ const SlicesConfig = {
         return { ...config, choices };
     },
 };
-function slicesReader(format) {
+function slicesReader(codec) {
     return t.exact(t.intersection([
         t.type({
             type: t.union([
@@ -72,13 +58,13 @@ function slicesReader(format) {
         }),
         t.partial({
             fieldset: validators_1.StringOrNull,
-            config: slicesConfigReader(format),
+            config: codec,
         }),
     ]));
 }
 exports.slicesReader = slicesReader;
-exports.StaticSlices = slicesReader(Format_1.Format.Static);
-exports.DynamicSlices = slicesReader(Format_1.Format.Dynamic);
+exports.StaticSlices = slicesReader(exports.StaticSlicesConfig);
+exports.DynamicSlices = slicesReader(exports.DynamicSlicesConfig);
 exports.Slices = {
     toStatic(slices, sharedSlices) {
         if (!slices.config)

package/lib/documents/DocumentData.d.ts

@@ -4,5 +4,14 @@ declare type DocumentData = Map<WidgetKey, O.Option<WidgetContent>>;
 declare 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>;
     fromJson(widgets: Map<WidgetKey, unknown>, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>): DocumentData;
+    partitionData(data: {
+        [p: string]: unknown;
+    }): {
+        types: Map<string, string>;
+        positions: Map<string, number>;
+        widgets: Map<WidgetKey, unknown>;
+        slugs: ReadonlyArray<string>;
+        uid: string | undefined;
+    };
 };
 export default DocumentData;

package/lib/documents/DocumentData.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/lib/Either");
 const O = (0, tslib_1.__importStar)(require("fp-ts/lib/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
 const widgets_1 = require("./widgets");
 function computeWidget(key, widgets, widgetTypes, widgetPositions) {
     const widget = widgets.get(key);
@@ -24,5 +26,45 @@ const DocumentData = {
             return new Map([...Array.from(acc.entries()), [widgetKey, parsedWidget]]);
         }, new Map());
     },
+    partitionData(data) {
+        const fields = Object.entries(data);
+        const { types, positions, widgets } = fields.reduce((acc, [k, v]) => {
+            if (k.endsWith("_TYPE")) {
+                const decodedValue = t.string.decode(v);
+                if ((0, Either_1.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(),
+            positions: new Map(),
+            widgets: new Map(),
+        });
+        const slugs = data["slugs_INTERNAL"] || [];
+        const uid = data["uid"];
+        return {
+            widgets,
+            types,
+            positions,
+            uid,
+            slugs,
+        };
+    },
 };
 exports.default = DocumentData;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "0.2.6",
+	"version": "0.2.9",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/customtypes/CustomType.ts

@@ -3,13 +3,7 @@ import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
 import { StringOrNull } from "../validators"
-import { Format } from "./Format"
-import {
-	DynamicSection,
-	sectionReader,
-	Sections,
-	StaticSection,
-} from "./Section"
+import { DynamicSection, Sections, StaticSection } from "./Section"
 import type { SharedSlice } from "./widgets/slices/SharedSlice"
 import type { DynamicSlice } from "./widgets/slices/Slice"
 import type { DynamicSlices } from "./widgets/slices/Slices"
@@ -35,14 +29,16 @@ ${slicesMsg.join("\n")}
 	}
 }
 
-function customTypeReader<F extends Format>(format: F) {
+function customTypeReader<T extends StaticSection | DynamicSection>(
+	codec: t.Type<T, unknown>,
+) {
 	return t.exact(
 		t.intersection([
 			t.type({
 				id: t.string,
 				label: StringOrNull,
 				repeatable: withFallback(t.boolean, true),
-				json: t.record(t.string, sectionReader(format)),
+				json: t.record(t.string, codec),
 				status: withFallback(t.boolean, true),
 			}),
 			t.partial({
@@ -52,10 +48,10 @@ function customTypeReader<F extends Format>(format: F) {
 	)
 }
 
-export const StaticCustomType = customTypeReader(Format.Static)
+export const StaticCustomType = customTypeReader(StaticSection)
 export type StaticCustomType = t.TypeOf<typeof StaticCustomType>
 
-export const CustomType = customTypeReader(Format.Dynamic)
+export const CustomType = customTypeReader(DynamicSection)
 export type CustomType = t.TypeOf<typeof CustomType>
 
 export function flattenWidgets(

package/src/customtypes/Section.ts

@@ -1,22 +1,18 @@
 import * as t from "io-ts"
 
-import { Format } from "./Format"
 import type { SharedSlice } from "./widgets/slices/SharedSlice"
-import {
-	DynamicWidget,
-	StaticWidget,
-	widgetReader,
-	Widgets,
-} from "./widgets/Widget"
+import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget"
 
-export function sectionReader<F extends Format>(format: F) {
-	return t.record(t.string, widgetReader(format))
+export function sectionReader<T extends StaticWidget | DynamicWidget>(
+	codec: t.Type<T, unknown>,
+) {
+	return t.record(t.string, codec)
 }
 
-export const StaticSection = sectionReader(Format.Static)
+export const StaticSection = sectionReader(StaticWidget)
 export type StaticSection = t.TypeOf<typeof StaticSection>
 
-export const DynamicSection = sectionReader(Format.Dynamic)
+export const DynamicSection = sectionReader(DynamicWidget)
 export type DynamicSection = t.TypeOf<typeof DynamicSection>
 
 export const Sections = {

package/src/customtypes/index.ts

@@ -1,4 +1,3 @@
 export * from "./CustomType"
-export { Format } from "./Format"
 export * as Section from "./Section"
 export * as Widgets from "./widgets"

package/src/customtypes/widgets/Widget.ts

@@ -1,20 +1,22 @@
 import * as t from "io-ts"
 
-import { Format } from "../Format"
 import Group from "./Group"
 import NestableWidget from "./nestable/NestableWidget"
 import type { SharedSlice } from "./slices/SharedSlice"
-import { Slices, slicesReader } from "./slices/Slices"
+import { DynamicSlices, Slices, StaticSlices } from "./slices/Slices"
 import UID from "./UID"
 import WidgetTypes from "./WidgetTypes"
 
-export function widgetReader<F extends Format>(format: F) {
-	return t.union([UID, NestableWidget, Group, slicesReader(format)])
+export function widgetReader<T extends StaticSlices | DynamicSlices>(
+	codec: t.Type<T, unknown>,
+) {
+	return t.union([UID, NestableWidget, Group, codec])
 }
-export const StaticWidget = widgetReader(Format.Static)
+
+export const StaticWidget = widgetReader(StaticSlices)
 export type StaticWidget = t.TypeOf<typeof StaticWidget>
 
-export const DynamicWidget = widgetReader(Format.Dynamic)
+export const DynamicWidget = widgetReader(DynamicSlices)
 export type DynamicWidget = t.TypeOf<typeof DynamicWidget>
 
 export const Widgets = {
@@ -23,6 +25,7 @@ export const Widgets = {
 		sharedSlices: Map<string, SharedSlice>,
 	): StaticWidget {
 		switch (widget.type) {
+			case WidgetTypes.LegacySlices:
 			case WidgetTypes.Slices:
 				return Slices.toStatic(widget, sharedSlices)
 			default:

package/src/customtypes/widgets/nestable/RichText.ts

@@ -202,7 +202,7 @@ const RichTextLabels = new t.Type<Array<string>, object, unknown>(
 	(res) => res,
 )
 
-const RichTextConfig = t.exact(
+export const RichTextConfig = t.exact(
 	t.partial({
 		label: StringOrNull,
 		placeholder: t.string,
@@ -214,7 +214,7 @@ const RichTextConfig = t.exact(
 		allowTargetBlank: t.boolean,
 	}),
 )
-type RichTextConfig = t.TypeOf<typeof RichTextConfig>
+export type RichTextConfig = t.TypeOf<typeof RichTextConfig>
 
 export const RichText = t.exact(
 	t.intersection([

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

@@ -1,7 +1,6 @@
 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"
@@ -9,7 +8,7 @@ import { SharedSlice } from "./SharedSlice"
 import SharedSliceRef from "./SharedSliceRef"
 import SlicesTypes from "./SlicesTypes"
 
-const SlicesLabels = t.union([
+export const SlicesLabels = t.union([
 	t.record(
 		t.string,
 		t.array(
@@ -27,39 +26,26 @@ const SlicesLabels = t.union([
 	),
 	t.null,
 ])
-type SlicesLabels = t.TypeOf<typeof SlicesLabels>
+export type SlicesLabels = t.TypeOf<typeof SlicesLabels>
 
-export function slicesConfigReader<F extends Format>(format: F) {
+export function slicesConfigReader<T extends SharedSlice | SharedSliceRef>(
+	codec: t.Type<T, unknown>,
+) {
 	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`,
-								)
-						}
-					})(),
-				]),
+				t.union([LegacySlice, CompositeSlice, codec]),
 			),
 		}),
 	)
 }
-export const StaticSlicesConfig = slicesConfigReader(Format.Static)
+export const StaticSlicesConfig = slicesConfigReader(SharedSlice)
 export type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>
 
-export const DynamicSlicesConfig = slicesConfigReader(Format.Dynamic)
+export const DynamicSlicesConfig = slicesConfigReader(SharedSliceRef)
 export type DynamicSlicesConfig = t.TypeOf<typeof DynamicSlicesConfig>
 
 const SlicesConfig = {
@@ -83,7 +69,9 @@ const SlicesConfig = {
 	},
 }
 
-export function slicesReader<F extends Format>(format: F) {
+export function slicesReader<
+	T extends StaticSlicesConfig | DynamicSlicesConfig,
+>(codec: t.Type<T, unknown>) {
 	return t.exact(
 		t.intersection([
 			t.type({
@@ -94,16 +82,16 @@ export function slicesReader<F extends Format>(format: F) {
 			}),
 			t.partial({
 				fieldset: StringOrNull,
-				config: slicesConfigReader(format),
+				config: codec,
 			}),
 		]),
 	)
 }
 
-export const StaticSlices = slicesReader(Format.Static)
+export const StaticSlices = slicesReader(StaticSlicesConfig)
 export type StaticSlices = t.TypeOf<typeof StaticSlices>
 
-export const DynamicSlices = slicesReader(Format.Dynamic)
+export const DynamicSlices = slicesReader(DynamicSlicesConfig)
 export type DynamicSlices = t.TypeOf<typeof DynamicSlices>
 
 export const Slices = {

package/src/documents/DocumentData.ts

@@ -1,4 +1,6 @@
+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"
 
@@ -49,6 +51,62 @@ const DocumentData = {
 			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/customtypes/Format.ts

@@ -1,4 +0,0 @@
-export enum Format {
-	Static = "static",
-	Dynamic = "dynamic",
-}