@prismicio/types-internal 2.2.0-traverse.alpha-1 → 2.2.0-traverse.alpha-2

package/lib/content/fields/slices/SlicesContent.d.ts

@@ -1,5 +1,5 @@
 import * as t from "io-ts";
-import type { ContentPath, TraverseContentFn } from "../../../_internal/utils";
+import { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../_internal/utils";
 import { type StaticSlices } from "../../../customtypes";
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
 export declare const SlicesContentType = "SliceContentType";
@@ -5095,9 +5095,10 @@ export declare const SlicesContent: t.TypeC<{
     }>>;
 }>;
 export declare type SlicesContent = t.TypeOf<typeof SlicesContent>;
-export declare function traverseSlices({ path, model, content, }: {
+export declare function traverseSlices({ path, key, model, content, }: {
     path: ContentPath;
+    key: string;
     content: SlicesContent;
     model?: StaticSlices | undefined;
-}): (transform: TraverseContentFn) => SlicesContent;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SlicesContent | undefined;
 export {};

package/lib/content/fields/slices/SlicesContent.js

@@ -5,14 +5,15 @@ const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const utils_1 = require("../../../_internal/utils");
 const customtypes_1 = require("../../../customtypes");
-const utils_1 = require("../../utils");
-const GroupContent_1 = require("../GroupContent");
+const utils_2 = require("../../utils");
 const CompositeSliceContent_1 = require("./Slice/CompositeSliceContent");
 const SharedSliceContent_1 = require("./Slice/SharedSliceContent");
+const SimpleSliceContent_1 = require("./Slice/SimpleSliceContent");
 const SliceItem_1 = require("./SliceItem");
 exports.SlicesContentType = "SliceContentType";
-const isSlicesContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.SlicesContentType;
+const isSlicesContent = (u) => (0, utils_2.hasContentType)(u) && u.__TYPE__ === exports.SlicesContentType;
 exports.isSlicesContent = isSlicesContent;
 const SlicesLegacy = (ctx) => {
     const codec = t.array((0, SliceItem_1.SlicesItemLegacy)(ctx));
@@ -36,66 +37,130 @@ exports.SlicesContent = t.type({
     __TYPE__: t.literal(exports.SlicesContentType),
     value: t.array(SliceItem_1.SliceItemContent),
 });
-function traverseSlices({ path, model, content, }) {
-    return (transform) => {
+function findSliceModel(slicesPath, model, content) {
+    var _a, _b;
+    const defaultModel = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) === null || _b === void 0 ? void 0 : _b[content.name];
+    // regular case for shared slices
+    const sharedSliceModel = () => {
+        if ((0, SliceItem_1.isSharedSliceItemContent)(content)) {
+            if (defaultModel && (0, customtypes_1.isStaticSharedSlice)(defaultModel)) {
+                const variationDef = defaultModel.variations.find((v) => v.id === content.widget.variation);
+                return variationDef
+                    ? {
+                        type: "SharedSlice",
+                        sliceName: defaultModel.id,
+                        variationId: variationDef.id,
+                        fields: {
+                            primary: variationDef.primary || {},
+                            items: variationDef.items || {},
+                        },
+                    }
+                    : undefined;
+            }
+        }
+        return;
+    };
+    const migratedSliceModel = () => {
+        var _a;
+        const legacyContentPath = utils_1.ContentPath.append(utils_1.ContentPath.serialize(slicesPath), content.name);
+        const migratedSliceModel = Object.values(((_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) || {}).find((sliceModel) => {
+            var _a;
+            if ((0, customtypes_1.isStaticSharedSlice)(sliceModel)) {
+                return !!((_a = sliceModel.legacyPaths) === null || _a === void 0 ? void 0 : _a[legacyContentPath]);
+            }
+            return false;
+        });
+        if (!migratedSliceModel)
+            return;
+        const migratedVariation = migratedSliceModel === null || migratedSliceModel === void 0 ? void 0 : migratedSliceModel.variations.find((v) => { var _a; return v.id === ((_a = migratedSliceModel.legacyPaths) === null || _a === void 0 ? void 0 : _a[legacyContentPath]); });
+        if (!migratedVariation)
+            return;
+        return {
+            type: "SharedSlice",
+            sliceName: migratedSliceModel.id,
+            variationId: migratedVariation.id,
+            fields: {
+                primary: migratedVariation.primary || {},
+                items: migratedVariation.items || {},
+            },
+        };
+    };
+    const legacySliceModel = () => {
+        if (!defaultModel)
+            return;
+        if ((0, customtypes_1.isCompositeSlice)(defaultModel)) {
+            return {
+                type: "Slice",
+                fields: {
+                    "non-repeat": defaultModel["non-repeat"] || {},
+                    repeat: defaultModel.repeat || {},
+                },
+            };
+        }
+        if ((0, customtypes_1.isLegacySlice)(defaultModel)) {
+            return defaultModel;
+        }
+        return;
+    };
+    return sharedSliceModel() || migratedSliceModel() || legacySliceModel();
+}
+function traverseSlices({ path, key, model, content, }) {
+    return (transformWidget, transformSlice) => {
         const value = content.value.reduce((acc, sliceContent) => {
-            var _a, _b;
-            const sliceModel = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) === null || _b === void 0 ? void 0 : _b[sliceContent.name];
-            const slicePath = path.concat({
-                key: sliceContent.key,
-                type: sliceContent.widget.__TYPE__,
-            });
-            const convertedSliceWidget = (() => {
-                switch (sliceContent.widget.__TYPE__) {
-                    case "SharedSliceContent":
-                        return (0, SharedSliceContent_1.traverseSharedSliceContent)({
-                            path: slicePath,
-                            sliceName: sliceContent.name,
-                            model: sliceModel && (0, customtypes_1.isStaticSharedSlice)(sliceModel)
-                                ? sliceModel
-                                : undefined,
-                            content: sliceContent.widget,
-                        })(transform);
-                    case "CompositeSliceContent":
-                        return (0, CompositeSliceContent_1.traverseCompositeSliceContent)({
-                            path: slicePath,
-                            sliceName: sliceContent.name,
-                            model: sliceModel && (0, customtypes_1.isCompositeSlice)(sliceModel)
-                                ? sliceModel
-                                : undefined,
-                            content: sliceContent.widget,
-                        })(transform);
-                    case "GroupContentType":
-                        return (0, GroupContent_1.traverseGroupContent)({
-                            path: slicePath,
-                            model: sliceModel &&
-                                (0, customtypes_1.isLegacySlice)(sliceModel) &&
-                                sliceModel.type === "Group"
-                                ? sliceModel
-                                : undefined,
-                            content: sliceContent.widget,
-                        })(transform);
-                    default:
-                        return sliceContent.widget;
-                }
+            const sliceModel = model && findSliceModel(path, model, sliceContent);
+            const convertedSlice = (() => {
+                if ((0, SliceItem_1.isSharedSliceItemContent)(sliceContent))
+                    return (0, SharedSliceContent_1.traverseSharedSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "SharedSlice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "SharedSlice" ? sliceModel : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                if ((0, SliceItem_1.isCompositeSliceItemContent)(sliceContent))
+                    return (0, CompositeSliceContent_1.traverseCompositeSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "Slice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "Slice" ||
+                            (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "SharedSlice"
+                            ? sliceModel
+                            : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                if ((0, SliceItem_1.isSimpleSliceItemContent)(sliceContent))
+                    return (0, SimpleSliceContent_1.traverseSimpleSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "LegacySlice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: sliceModel && (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) !== "Slice"
+                            ? sliceModel
+                            : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                return;
             })();
-            const convertedSlice = transform({
-                key: sliceContent.key,
-                apiId: sliceContent.name,
-                path: slicePath,
-                model: sliceModel,
-                content: convertedSliceWidget,
-            });
-            const convertedSliceParent = convertedSlice && {
-                ...sliceContent,
-                widget: convertedSlice,
-            };
-            return convertedSliceParent ? acc.concat(convertedSliceParent) : acc;
+            return convertedSlice ? acc.concat(convertedSlice) : acc;
         }, []);
-        return {
-            __TYPE__: content.__TYPE__,
-            value,
-        };
+        return transformWidget({
+            path,
+            key,
+            apiId: key,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                value,
+            },
+        });
     };
 }
 exports.traverseSlices = traverseSlices;

package/lib/customtypes/CustomType.d.ts

@@ -1344,6 +1344,9 @@ export declare const StaticCustomType: t.ExactC<t.IntersectionC<[t.TypeC<{
                         })[];
                     } & {
                         description?: string;
+                        legacyPaths?: {
+                            [x: string]: string;
+                        };
                     });
                 };
             };
@@ -2396,4 +2399,5 @@ export declare function validateSlices(customType: CustomType, sharedSlices: Map
 export declare function collectWidgets(customType: CustomType, f: (ref: string, widget: DynamicWidget) => DynamicWidget | undefined): CustomType;
 export declare function filterMissingSharedSlices(customType: CustomType, sharedSlices: Map<string, SharedSlice>): CustomType;
 export declare function flattenCustomTypeFields(customType: StaticCustomType): Partial<Record<string, StaticWidget>>;
+export declare function collectSharedSlices(customType: StaticCustomType): Record<string, SharedSlice>;
 export {};

package/lib/customtypes/CustomType.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenCustomTypeFields = exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.flattenStaticWidgets = exports.flattenWidgets = exports.CustomType = exports.StaticCustomType = exports.CustomTypeFormat = void 0;
+exports.collectSharedSlices = exports.flattenCustomTypeFields = exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.flattenStaticWidgets = exports.flattenWidgets = exports.CustomType = exports.StaticCustomType = exports.CustomTypeFormat = void 0;
 const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
@@ -147,3 +147,20 @@ function flattenCustomTypeFields(customType) {
     }), {});
 }
 exports.flattenCustomTypeFields = flattenCustomTypeFields;
+function collectSharedSlices(customType) {
+    return flattenStaticWidgets(customType).reduce((acc, [, w]) => {
+        var _a;
+        if (w.type === "Slices" || w.type === "Choice") {
+            return {
+                ...acc,
+                ...Object.entries(((_a = w.config) === null || _a === void 0 ? void 0 : _a.choices) || {}).reduce((sliceZoneAcc, [sliceKey, sliceModel]) => {
+                    return sliceModel.type === "SharedSlice"
+                        ? { ...sliceZoneAcc, [sliceKey]: sliceModel }
+                        : sliceZoneAcc;
+                }, {}),
+            };
+        }
+        return acc;
+    }, {});
+}
+exports.collectSharedSlices = collectSharedSlices;

package/lib/customtypes/Section.d.ts

@@ -1328,6 +1328,9 @@ export declare const StaticSection: t.RecordC<t.Type<string, string, unknown>, t
                 })[];
             } & {
                 description?: string;
+                legacyPaths?: {
+                    [x: string]: string;
+                };
             });
         };
     };

package/lib/customtypes/diff/SharedSlice.d.ts

@@ -340,6 +340,9 @@ export declare const SliceComparator: {
         })[];
     } & {
         description?: string;
+        legacyPaths?: {
+            [x: string]: string;
+        };
     }) | undefined, sliceB?: ({
         id: string;
         type: "SharedSlice";
@@ -674,5 +677,8 @@ export declare const SliceComparator: {
         })[];
     } & {
         description?: string;
+        legacyPaths?: {
+            [x: string]: string;
+        };
     }) | undefined): SliceDiff | undefined;
 };

package/lib/customtypes/widgets/Widget.d.ts

@@ -1667,6 +1667,9 @@ export declare const StaticWidget: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
                 })[];
             } & {
                 description?: string;
+                legacyPaths?: {
+                    [x: string]: string;
+                };
             });
         };
     };

package/lib/customtypes/widgets/slices/CompositeSlice.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { PickOnly } from "../../../_internal/utils";
 import type { DynamicSlice, StaticSlice } from "./Slice";
 export declare const CompositeSliceType = "Slice";
 export declare const CompositeSliceConfig: t.ExactC<t.PartialC<{
@@ -331,4 +332,8 @@ export declare const CompositeSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>>;
 }>]>>;
 export declare type CompositeSlice = t.TypeOf<typeof CompositeSlice>;
+export declare type CompositeSliceFields = {
+    type: "Slice";
+    fields: PickOnly<CompositeSlice, "non-repeat" | "repeat">;
+};
 export declare function isCompositeSlice(slice: DynamicSlice | StaticSlice): slice is CompositeSlice;

package/lib/customtypes/widgets/slices/SharedSlice.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { PickOnly } from "../../../_internal/utils";
 import type { SharedSliceRef } from "./SharedSliceRef";
 import type { DynamicSlice, StaticSlice } from "./Slice";
 export declare const Variation: t.ExactC<t.IntersectionC<[t.TypeC<{
@@ -326,6 +327,12 @@ export declare const Variation: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>]>>]>>;
 }>]>>;
 export declare type Variation = t.TypeOf<typeof Variation>;
+export declare type VariationFields = {
+    type: "SharedSlice";
+    sliceName: string;
+    variationId: string;
+    fields: PickOnly<Variation, "primary" | "items">;
+};
 export declare const SharedSliceType = "SharedSlice";
 export declare const SharedSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
     id: t.StringC;
@@ -657,6 +664,7 @@ export declare const SharedSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>]>>>;
 }>, t.PartialC<{
     description: t.StringC;
+    legacyPaths: t.RecordC<t.StringC, t.StringC>;
 }>]>>;
 export declare type SharedSlice = t.TypeOf<typeof SharedSlice>;
 export declare function isStaticSharedSlice(slice: StaticSlice): slice is SharedSlice;

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

@@ -23,6 +23,8 @@ exports.Variation = t.exact(t.intersection([
     }),
 ]));
 exports.SharedSliceType = "SharedSlice";
+const LegacyPath = t.string;
+const VariationId = t.string;
 exports.SharedSlice = t.exact(t.intersection([
     t.type({
         id: t.string,
@@ -32,6 +34,7 @@ exports.SharedSlice = t.exact(t.intersection([
     }),
     t.partial({
         description: t.string,
+        legacyPaths: t.record(LegacyPath, VariationId),
     }),
 ]));
 function isStaticSharedSlice(slice) {

package/lib/customtypes/widgets/slices/Slices.d.ts

@@ -1653,6 +1653,9 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
         })[];
     } & {
         description?: string;
+        legacyPaths?: {
+            [x: string]: string;
+        };
     }, unknown, unknown>]>>;
 }>>;
 export declare type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>;
@@ -3328,6 +3331,9 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                 })[];
             } & {
                 description?: string;
+                legacyPaths?: {
+                    [x: string]: string;
+                };
             });
         };
     }, unknown, unknown>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/utils.d.ts

@@ -335,5 +335,8 @@ export declare const findSlice: (slices: SharedSliceCustomType[]) => (sliceId: s
     })[];
 } & {
     description?: string;
+    legacyPaths?: {
+        [x: string]: string;
+    };
 }>;
 export declare const findSliceVariation: (slice: SharedSliceCustomType) => (variation: string) => E.Either<string, Variation>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-traverse.alpha-1",
+	"version": "2.2.0-traverse.alpha-2",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/_internal/utils.ts

@@ -1,9 +1,41 @@
-import type { SliceContent, WidgetContent } from "../content"
-import type { StaticSlice, StaticWidget } from "../customtypes"
+import type {
+	SharedSliceItemContent,
+	SliceItemContent,
+	WidgetContent,
+} from "../content"
+import type {
+	CompositeSliceFields,
+	Group,
+	NestableWidget,
+	StaticSlices,
+	UID,
+	VariationFields,
+} from "../customtypes"
 
-export type TraverseContentFn = <
-	C extends WidgetContent | SliceContent,
-	D extends StaticWidget | StaticSlice,
+export type PickOnly<T, K extends keyof T> = Pick<T, K> & {
+	[P in Exclude<keyof T, K>]?: never
+}
+
+export type TraverseSliceContentFn = <
+	S extends SliceItemContent | SharedSliceItemContent,
+	D extends VariationFields | CompositeSliceFields | Group | NestableWidget,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model?: D | undefined
+	content: S
+}) => S | SharedSliceItemContent | undefined
+
+export type TraverseWidgetContentFn = <
+	C extends WidgetContent,
+	D extends NestableWidget | StaticSlices | Group | UID,
 >({
 	path,
 	key,
@@ -21,8 +53,10 @@ export type TraverseContentFn = <
 export type ContentPathEntry = {
 	type:
 		| "CustomType"
-		| WidgetContent["__TYPE__"]
-		| SliceContent["__TYPE__"]
+		| "Widget"
+		| "SharedSlice"
+		| "Slice"
+		| "LegacySlice"
 		| "GroupItem"
 		| "primary"
 		| "items"
@@ -36,4 +70,26 @@ export const ContentPath = {
 	serialize(path: ContentPath): string {
 		return path.map((entry) => entry.key).join(PATH_SEPARATOR)
 	},
+	current(path: ContentPath): ContentPathEntry | undefined {
+		return path[path.length - 1]
+	},
+	append(path: string, strElement: string): string {
+		return path + PATH_SEPARATOR + strElement
+	},
+	make(
+		entries: Array<{
+			key?: ContentPathEntry["key"] | undefined
+			type: ContentPathEntry["type"]
+		}>,
+	): ContentPath {
+		return entries.reduce<ContentPath>((acc, { key, type }) => {
+			return key ? acc.concat({ key, type }) : acc
+		}, [])
+	},
 }
+
+export type SliceModel =
+	| VariationFields
+	| NestableWidget
+	| CompositeSliceFields
+	| Group