@prismicio/types-internal 0.1.0 → 0.1.1

package/dist/customtypes/CustomType.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.CustomType = exports.StaticCustomType = void 0;
+const t = __importStar(require("io-ts"));
+const StringOrNull_1 = require("../validators/StringOrNull");
+const Either_1 = require("fp-ts/lib/Either");
+const withFallback_1 = require("io-ts-types/lib/withFallback");
+const Format_1 = require("./Format");
+const WidgetTypes_1 = __importDefault(require("./widgets/WidgetTypes"));
+const SlicesTypes_1 = __importDefault(require("./widgets/slices/SlicesTypes"));
+const Section_1 = require("./Section");
+class CustomTypeSlicesError extends Error {
+    slices;
+    message;
+    constructor(slices) {
+        super();
+        this.slices = slices;
+        this.message = this._formatError(slices);
+    }
+    _formatError(slicesRefs) {
+        const slicesMsg = slicesRefs.map(ref => `\t - ${ref}`);
+        return (`The following slices doesn't exists in your Prismic repository:
+${slicesMsg.join('\n')}
+`);
+    }
+}
+function customTypeReader(format) {
+    return t.exact(t.intersection([
+        t.type({
+            id: t.string,
+            label: StringOrNull_1.StringOrNull,
+            repeatable: (0, withFallback_1.withFallback)(t.boolean, true),
+            json: t.record(t.string, (0, Section_1.sectionReader)(format)),
+            status: (0, withFallback_1.withFallback)(t.boolean, true)
+        }),
+        t.partial({
+            hash: t.string
+        })
+    ]));
+}
+exports.StaticCustomType = customTypeReader(Format_1.Format.Static);
+exports.CustomType = customTypeReader(Format_1.Format.Dynamic);
+function _retrieveSharedSlicesRef(customType) {
+    const flattenWidgets = Object.entries(customType.json)
+        .reduce((acc, [, section]) => {
+        const sectionWidgets = Object.entries(section);
+        return acc.concat(sectionWidgets);
+    }, []);
+    const slicezones = flattenWidgets.filter(([, widget]) => widget.type === WidgetTypes_1.default.Slices);
+    const allSharedRefs = slicezones.reduce((acc, [, slicezone]) => {
+        const sharedRefs = Object.entries(slicezone.config && slicezone.config.choices ? slicezone.config.choices : {})
+            .filter(([, slice]) => slice.type === SlicesTypes_1.default.SharedSlice)
+            .map(([key]) => key);
+        return acc.concat(sharedRefs);
+    }, []);
+    return allSharedRefs;
+}
+function _mapSharedSlicesRefs(customType) {
+    const refs = _retrieveSharedSlicesRef(customType);
+    return function (mapFn) {
+        return refs.map(mapFn);
+    };
+}
+function toStatic(customType, sharedSlices) {
+    const json = Object.entries(customType.json)
+        .reduce((acc, [sectionKey, dynSection]) => {
+        return { ...acc, [sectionKey]: Section_1.Sections.toStatic(dynSection, sharedSlices) };
+    }, {});
+    return { ...customType, json };
+}
+exports.toStatic = toStatic;
+function validateSlices(customType, sharedSlices) {
+    const missingSlices = _mapSharedSlicesRefs(customType)((ref) => {
+        const slice = sharedSlices.get(ref);
+        const isMissing = !Boolean(slice);
+        if (isMissing)
+            return ref;
+    }).filter(Boolean);
+    if (missingSlices.length > 0)
+        return (0, Either_1.left)(new CustomTypeSlicesError(missingSlices));
+    else
+        return (0, Either_1.right)(customType);
+}
+exports.validateSlices = validateSlices;
+function collectWidgets(customType, f) {
+    const json = Object.entries(customType.json)
+        .reduce((acc, [sectionId, section]) => {
+        const updatedSection = Object
+            .entries(section)
+            .reduce((acc, [ref, widget]) => {
+            const updatedWidget = f(ref, widget);
+            if (!!updatedWidget) {
+                return { ...acc, [ref]: updatedWidget };
+            }
+            return acc;
+        }, {});
+        return { ...acc, [sectionId]: updatedSection };
+    }, {});
+    return { ...customType, json };
+}
+exports.collectWidgets = collectWidgets;
+function filterMissingSharedSlices(customType, sharedSlices) {
+    return collectWidgets(customType, (_widgetId, widget) => {
+        if (widget.type === WidgetTypes_1.default.Slices) {
+            if (!widget.config || !widget.config.choices)
+                return widget;
+            const choices = Object.entries(widget.config.choices)
+                .reduce((acc, [sliceId, sliceValue]) => {
+                if (sliceValue.type === SlicesTypes_1.default.SharedSlice && !sharedSlices.get(sliceId))
+                    return acc;
+                return { ...acc, [sliceId]: sliceValue };
+            }, {});
+            const config = { ...widget.config, choices };
+            return { ...widget, config };
+        }
+        return widget;
+    });
+}
+exports.filterMissingSharedSlices = filterMissingSharedSlices;

package/dist/customtypes/Format.d.ts

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

package/dist/customtypes/Format.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Format = void 0;
+var Format;
+(function (Format) {
+    Format["Static"] = "static";
+    Format["Dynamic"] = "dynamic";
+})(Format = exports.Format || (exports.Format = {}));