@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSharedSlice = exports.traverseVariation = exports.isDynamicSharedSlice = exports.isStaticSharedSlice = exports.SharedSlice = exports.SharedSliceType = exports.Variation = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const withFallback_1 = require("io-ts-types/lib/withFallback");
+const common_1 = require("../../../common");
+const Group_1 = require("../Group");
+const NestableWidget_1 = require("../nestable/NestableWidget");
+const SlicePrimaryWidget_1 = require("./SlicePrimaryWidget");
+const IMAGE_PLACEHOLDER_URL = "https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format";
+exports.Variation = t.exact(t.intersection([
+    t.type({
+        id: t.string,
+        name: t.string,
+        description: t.string,
+        imageUrl: (0, withFallback_1.withFallback)(t.string, IMAGE_PLACEHOLDER_URL),
+        docURL: t.string,
+        version: t.string,
+    }),
+    t.partial({
+        display: t.string,
+        primary: t.record(common_1.WidgetKey, SlicePrimaryWidget_1.SlicePrimaryWidget),
+        items: t.record(common_1.WidgetKey, NestableWidget_1.NestableWidget),
+    }),
+]));
+exports.SharedSliceType = "SharedSlice";
+const LegacyPath = t.string;
+const VariationId = t.string;
+exports.SharedSlice = t.exact(t.intersection([
+    t.type({
+        id: t.string,
+        type: t.literal(exports.SharedSliceType),
+        name: t.string,
+        variations: t.readonlyArray(exports.Variation),
+    }),
+    t.partial({
+        description: t.string,
+        legacyPaths: t.record(LegacyPath, VariationId),
+    }),
+]));
+function isStaticSharedSlice(slice) {
+    return slice.type === "SharedSlice";
+}
+exports.isStaticSharedSlice = isStaticSharedSlice;
+function isDynamicSharedSlice(slice) {
+    return slice.type === "SharedSlice";
+}
+exports.isDynamicSharedSlice = isDynamicSharedSlice;
+function traverseVariation(args) {
+    var _a, _b;
+    const { path: prevPath, variation, onField } = args;
+    let primary;
+    for (const [key, prevField] of Object.entries((_a = variation.primary) !== null && _a !== void 0 ? _a : {})) {
+        const path = [...prevPath, "primary", key];
+        let field;
+        switch (prevField.type) {
+            case "Group":
+                field = (0, Group_1.traverseGroup)({
+                    path,
+                    group: prevField,
+                    onField: onField,
+                });
+                break;
+            default:
+                field = prevField;
+                break;
+        }
+        const newField = onField({ path, key, field });
+        if (field !== newField) {
+            if (!primary)
+                primary = { ...variation.primary };
+            primary[key] = newField;
+        }
+    }
+    let items;
+    for (const [key, prevField] of Object.entries((_b = variation.items) !== null && _b !== void 0 ? _b : {})) {
+        const path = [...prevPath, "items", key];
+        const newField = onField({
+            path,
+            key,
+            field: prevField,
+        });
+        if (prevField !== newField) {
+            if (!items)
+                items = { ...variation.items };
+            items[key] = newField;
+        }
+    }
+    // returns the traversed model instead of a new one if it didn't change
+    return primary || items
+        ? { ...variation, ...(primary && { primary }), ...(items && { items }) }
+        : variation;
+}
+exports.traverseVariation = traverseVariation;
+function traverseSharedSlice(args) {
+    const { path: prevPath, slice, onField } = args;
+    let variations;
+    for (let i = 0; i < slice.variations.length; i++) {
+        const variation = slice.variations[i];
+        if (!variation)
+            continue;
+        const path = [...prevPath, variation.id];
+        const newVariation = traverseVariation({
+            path,
+            variation,
+            onField,
+        });
+        if (newVariation !== variation) {
+            if (!variations)
+                variations = [...slice.variations];
+            variations[i] = newVariation;
+        }
+    }
+    // returns the traversed model instead of a new one if it didn't change
+    return variations ? { ...slice, variations } : slice;
+}
+exports.traverseSharedSlice = traverseSharedSlice;

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

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare const SharedSliceRef: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"SharedSlice">;
+}>>;
+export declare type SharedSliceRef = t.TypeOf<typeof SharedSliceRef>;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceRef = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SharedSlice_1 = require("./SharedSlice");
+exports.SharedSliceRef = t.exact(t.type({
+    type: t.literal(SharedSlice_1.SharedSliceType),
+}));

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

@@ -0,0 +1,6 @@
+import type { CompositeSlice } from "./CompositeSlice";
+import type { LegacySlice } from "./LegacySlice";
+import type { SharedSlice } from "./SharedSlice";
+import type { SharedSliceRef } from "./SharedSliceRef";
+export declare type DynamicSlice = CompositeSlice | LegacySlice | SharedSliceRef;
+export declare type StaticSlice = CompositeSlice | LegacySlice | SharedSlice;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });