@prismicio/types-internal 0.1.0

package/dist/index.js

@@ -0,0 +1,844 @@
+import * as t from 'io-ts';
+import { NumberFromString } from 'io-ts-types/lib/NumberFromString';
+import { chain, either, left, right } from 'fp-ts/lib/Either';
+import { IntFromString } from 'io-ts-types/lib/IntFromString';
+import { pipe } from 'fp-ts/lib/pipeable';
+import { withFallback } from 'io-ts-types/lib/withFallback';
+
+var Format;
+(function(Format2) {
+  Format2["Static"] = "static";
+  Format2["Dynamic"] = "dynamic";
+})(Format || (Format = {}));
+
+const StringOrNull = t.union([t.string, t.null, t.undefined]);
+
+var WidgetTypes;
+(function(WidgetTypes2) {
+  WidgetTypes2["Text"] = "Text";
+  WidgetTypes2["RichText"] = "StructuredText";
+  WidgetTypes2["Color"] = "Color";
+  WidgetTypes2["Image"] = "Image";
+  WidgetTypes2["Date"] = "Date";
+  WidgetTypes2["Timestamp"] = "Timestamp";
+  WidgetTypes2["Number"] = "Number";
+  WidgetTypes2["Range"] = "Range";
+  WidgetTypes2["Select"] = "Select";
+  WidgetTypes2["Link"] = "Link";
+  WidgetTypes2["Embed"] = "Embed";
+  WidgetTypes2["GeoPoint"] = "GeoPoint";
+  WidgetTypes2["Separator"] = "Separator";
+  WidgetTypes2["UID"] = "UID";
+  WidgetTypes2["BooleanField"] = "Boolean";
+  WidgetTypes2["IntegrationField"] = "IntegrationFields";
+  WidgetTypes2["Group"] = "Group";
+  WidgetTypes2["Slices"] = "Slices";
+  WidgetTypes2["LegacySlices"] = "Choice";
+})(WidgetTypes || (WidgetTypes = {}));
+var WidgetTypes$1 = WidgetTypes;
+
+const UIDConfig = t.exact(t.partial({
+  label: StringOrNull,
+  useAsTitle: t.boolean,
+  placeholder: t.string
+}));
+const UID = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.UID)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: UIDConfig
+  })
+]));
+
+const ColorConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string
+}));
+const Color = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Color)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: ColorConfig
+  })
+]));
+
+const BooleanConfig = t.exact(t.partial({
+  label: StringOrNull,
+  default_value: t.boolean,
+  placeholder_true: t.string,
+  placeholder_false: t.string
+}));
+const BooleanField = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.BooleanField)
+  }),
+  t.partial({
+    config: BooleanConfig
+  })
+]));
+
+const DateConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  default: t.string
+}));
+const Date = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Date)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: DateConfig
+  })
+]));
+
+const EmbedConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  useAsTitle: t.boolean
+}));
+const Embed = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Embed)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: EmbedConfig
+  })
+]));
+
+const GeoPointConfig = t.exact(t.partial({
+  label: StringOrNull
+}));
+const GeoPoint = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.GeoPoint)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: GeoPointConfig
+  })
+]));
+
+const NumberConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  min: t.union([t.number, NumberFromString]),
+  max: t.union([t.number, NumberFromString]),
+  step: t.union([t.number, NumberFromString])
+}));
+const Number = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Number)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: NumberConfig
+  })
+]));
+
+const RangeConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  min: t.union([t.number, NumberFromString]),
+  max: t.union([t.number, NumberFromString]),
+  step: t.union([t.number, NumberFromString])
+}));
+const Range = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Range)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: RangeConfig
+  })
+]));
+
+const IntFromNumber = new t.Type("IntFromNumber", t.Int.is, (u, c) => pipe(t.number.validate(u, c), chain((n) => {
+  if (t.Int.is(n))
+    return t.success(n);
+  else {
+    return t.success(Math.round(n));
+  }
+})), t.Int.encode);
+
+const PixelsRegex = /^([0-9]+)px$/;
+const IntFromPixels = new t.Type("IntFromPixels", t.Int.is, (u, c) => pipe(t.string.validate(u, c), chain((strPixels) => {
+  try {
+    const matched = strPixels.match(PixelsRegex);
+    if (!matched)
+      return t.failure(u, c);
+    else {
+      const parsed = parseInt(matched[1]);
+      return t.success(parsed);
+    }
+  } catch (e) {
+    return t.failure(u, c);
+  }
+})), String);
+
+const SideConstraint = new t.Type("SideConstraints", (u) => {
+  return !u || typeof u === "number";
+}, (u, context) => {
+  return either.chain(t.union([
+    t.literal("auto"),
+    t.literal(""),
+    t.Int,
+    IntFromString,
+    IntFromNumber,
+    IntFromPixels,
+    t.null
+  ]).validate(u, context), (constraint) => {
+    if (constraint === "auto" || constraint === "")
+      return t.success(null);
+    return t.success(constraint);
+  });
+}, (res) => res);
+const ImageConstraint = t.partial({
+  width: SideConstraint,
+  height: SideConstraint
+});
+
+const DEFAULT_OPTION = "paragraph";
+const options = [
+  "heading1",
+  "heading2",
+  "heading3",
+  "heading4",
+  "heading5",
+  "heading6",
+  "paragraph",
+  "strong",
+  "em",
+  "preformatted",
+  "hyperlink",
+  "image",
+  "embed",
+  "list-item",
+  "o-list-item",
+  "rtl"
+];
+const RichTextOptions = new t.Type("RichTextOptions", (u) => typeof u === "string", (u, context) => {
+  return either.chain(t.union([
+    t.string,
+    t.null
+  ]).validate(u, context), (s) => {
+    if (!s)
+      return t.success(DEFAULT_OPTION);
+    const entries = s.split(",").map((e) => e.trim());
+    const filtered = entries.filter((entry) => options.includes(entry));
+    if (!filtered.length)
+      return t.success(DEFAULT_OPTION);
+    return t.success(filtered.join(","));
+  });
+}, (a) => a);
+const NoLabels = (labels) => {
+  if (!labels)
+    return t.success([]);
+};
+const LabelsAsObject = (labels) => {
+  if (labels instanceof Object) {
+    const labelsObj = labels;
+    if (!Object.entries(labelsObj).length)
+      return t.success([]);
+    if (labelsObj[""]) {
+      return t.success(labelsObj[""].map((l) => l.name));
+    }
+    const convertedObjectToArray = Object.entries(labelsObj).reduce((acc, [, labelsEntries]) => {
+      return acc.concat(labelsEntries.map((l) => l.name));
+    }, []).filter(Boolean);
+    return t.success(convertedObjectToArray);
+  }
+};
+const LabelsAsArray = (labels) => {
+  if (labels instanceof Array) {
+    const isValidLabels = labels.reduce((acc, l) => acc && typeof l === "string", true);
+    if (isValidLabels)
+      return t.success(labels);
+  }
+};
+const LabelsAsString = (labels) => {
+  if (typeof labels === "string") {
+    return t.success([labels]);
+  }
+};
+const RichTextLabels = new t.Type("RichTextLabels", (u) => {
+  return u instanceof Array;
+}, (u, context) => {
+  const legacyValidator = t.record(t.string, t.array(t.record(t.literal("name"), t.string)));
+  const validator = t.array(t.string);
+  return either.chain(t.union([
+    legacyValidator,
+    validator,
+    t.string,
+    t.null
+  ]).validate(u, context), (labels) => {
+    return NoLabels(labels) || LabelsAsArray(labels) || LabelsAsObject(labels) || LabelsAsString(labels) || t.failure(u, context);
+  });
+}, (res) => res);
+const RichTextConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  useAsTitle: t.boolean,
+  single: RichTextOptions,
+  multi: RichTextOptions,
+  imageConstraint: ImageConstraint,
+  labels: RichTextLabels,
+  allowTargetBlank: t.boolean
+}));
+const RichText = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.RichText)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: RichTextConfig
+  })
+]));
+
+const StringFromBoolean = new t.Type("StringFromInt", t.string.is, (u, c) => pipe(t.boolean.validate(u, c), chain((i) => {
+  return t.success(i.toString());
+})), (i) => i);
+
+const StringFromNumber = new t.Type("StringFromInt", t.string.is, (u, c) => pipe(t.number.validate(u, c), chain((i) => {
+  return t.success(i.toString());
+})), (i) => i);
+
+const SelectConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  default_value: t.string,
+  options: t.array(t.union([t.string, StringFromNumber, StringFromBoolean]))
+}));
+const Select = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Select)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: SelectConfig
+  })
+]));
+
+const SeparatorConfig = t.exact(t.partial({
+  label: StringOrNull
+}));
+const Separator = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Separator)
+  }),
+  t.partial({
+    config: SeparatorConfig
+  })
+]));
+
+const TextConfig = t.exact(t.partial({
+  label: StringOrNull,
+  useAsTitle: t.boolean,
+  placeholder: t.string
+}));
+const Text = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Text)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: TextConfig
+  })
+]));
+
+const TimestampConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  default: t.string
+}));
+const Timestamp = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Timestamp)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: TimestampConfig
+  })
+]));
+
+const arrayString = (entries) => {
+  if (entries instanceof Array) {
+    const isValidEntries = entries.reduce((acc, l) => acc && typeof l === "string", true);
+    if (isValidEntries)
+      return t.success(entries);
+  }
+};
+const plainString = (entries) => {
+  if (typeof entries === "string") {
+    return t.success([entries]);
+  }
+};
+const MasksArrayString = new t.Type("MasksArrayString", (u) => {
+  return u instanceof Array;
+}, (u, context) => {
+  return either.chain(t.union([
+    t.array(t.string),
+    t.string
+  ]).validate(u, context), (masks) => {
+    return arrayString(masks) || plainString(masks) || t.failure(u, context);
+  });
+}, (res) => res);
+const LinkConfig = t.exact(t.partial({
+  label: StringOrNull,
+  useAsTitle: t.boolean,
+  placeholder: t.string,
+  select: withFallback(t.union([
+    t.literal("media"),
+    t.literal("document"),
+    t.literal("web"),
+    t.null
+  ]), null),
+  customtypes: t.array(t.string),
+  masks: MasksArrayString,
+  tags: MasksArrayString,
+  allowTargetBlank: t.boolean
+}));
+const Link = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Link)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: LinkConfig
+  })
+]));
+
+const Thumbnail = t.exact(t.intersection([
+  t.type({
+    name: t.string
+  }),
+  ImageConstraint
+]));
+const ImageConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  constraint: ImageConstraint,
+  thumbnails: t.array(Thumbnail)
+}));
+const Image = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Image)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: ImageConfig
+  })
+]));
+
+const IntegrationFieldConfig = t.exact(t.partial({
+  label: StringOrNull,
+  placeholder: t.string,
+  catalog: t.string
+}));
+const IntegrationField = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.IntegrationField)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    config: IntegrationFieldConfig
+  })
+]));
+
+const NestableWidget = t.union([
+  Color,
+  BooleanField,
+  Embed,
+  GeoPoint,
+  Date,
+  Number,
+  Range,
+  RichText,
+  Select,
+  Separator,
+  Text,
+  Timestamp,
+  Link,
+  Image,
+  IntegrationField
+]);
+
+const GroupConfig = t.exact(t.partial({
+  label: StringOrNull,
+  repeat: t.boolean,
+  fields: t.record(t.string, NestableWidget)
+}));
+const Group = t.exact(t.intersection([
+  t.type({
+    type: t.literal(WidgetTypes$1.Group)
+  }),
+  t.partial({
+    fieldset: StringOrNull,
+    icon: t.string,
+    description: t.string,
+    config: GroupConfig
+  })
+]));
+
+const LegacySlice = t.union([
+  UID,
+  NestableWidget,
+  Group
+]);
+
+var SlicesTypes;
+(function(SlicesTypes2) {
+  SlicesTypes2["Slice"] = "Slice";
+  SlicesTypes2["SharedSlice"] = "SharedSlice";
+})(SlicesTypes || (SlicesTypes = {}));
+var SlicesTypes$1 = SlicesTypes;
+
+const CompositeSliceConfig = t.exact(t.partial({
+  label: StringOrNull
+}));
+const CompositeSlice = t.exact(t.intersection([
+  t.type({
+    type: t.literal(SlicesTypes$1.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
+  })
+]));
+
+const SharedSliceRef = t.exact(t.type({
+  type: t.literal(SlicesTypes$1.SharedSlice)
+}));
+
+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)
+  })
+]));
+const SharedSlice = t.exact(t.intersection([
+  t.type({
+    id: t.string,
+    type: t.literal(SlicesTypes$1.SharedSlice),
+    name: t.string,
+    variations: t.array(Variation)
+  }),
+  t.partial({
+    description: t.string
+  })
+]));
+
+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
+]);
+function slicesConfigReader(format) {
+  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`);
+        }
+      })()
+    ]))
+  }));
+}
+const StaticSlicesConfig = slicesConfigReader(Format.Static);
+const DynamicSlicesConfig = slicesConfigReader(Format.Dynamic);
+const SlicesConfig = {
+  toStatic(config, sharedSlices) {
+    const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
+      if (slice.type === SlicesTypes$1.SharedSlice) {
+        const sharedSlice = sharedSlices.get(ref);
+        if (sharedSlice)
+          return { ...acc, [ref]: sharedSlice };
+        else
+          return acc;
+      } else {
+        return { ...acc, [ref]: slice };
+      }
+    }, {});
+    return { ...config, choices };
+  }
+};
+function slicesReader(format) {
+  return t.exact(t.intersection([
+    t.type({
+      type: t.union([t.literal(WidgetTypes$1.Slices), t.literal(WidgetTypes$1.LegacySlices)])
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: slicesConfigReader(format)
+    })
+  ]));
+}
+const StaticSlices = slicesReader(Format.Static);
+const DynamicSlices = slicesReader(Format.Dynamic);
+const Slices = {
+  toStatic(slices, sharedSlices) {
+    if (!slices.config)
+      return slices;
+    else {
+      return { ...slices, config: SlicesConfig.toStatic(slices.config, sharedSlices) };
+    }
+  }
+};
+
+var Slices$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  slicesConfigReader: slicesConfigReader,
+  StaticSlicesConfig: StaticSlicesConfig,
+  DynamicSlicesConfig: DynamicSlicesConfig,
+  slicesReader: slicesReader,
+  StaticSlices: StaticSlices,
+  DynamicSlices: DynamicSlices,
+  Slices: Slices
+});
+
+function widgetReader(format) {
+  return t.union([
+    UID,
+    NestableWidget,
+    Group,
+    slicesReader(format)
+  ]);
+}
+const StaticWidget = widgetReader(Format.Static);
+const DynamicWidget = widgetReader(Format.Dynamic);
+const Widgets = {
+  toStatic(widget, sharedSlices) {
+    switch (widget.type) {
+      case WidgetTypes$1.Slices:
+        return Slices.toStatic(widget, sharedSlices);
+      default:
+        return widget;
+    }
+  }
+};
+
+var Widget = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  widgetReader: widgetReader,
+  StaticWidget: StaticWidget,
+  DynamicWidget: DynamicWidget,
+  Widgets: Widgets
+});
+
+function sectionReader(format) {
+  return t.record(t.string, widgetReader(format));
+}
+const StaticSection = sectionReader(Format.Static);
+const DynamicSection = sectionReader(Format.Dynamic);
+const Sections = {
+  toStatic(dynamic, sharedSlices) {
+    const section = Object.entries(dynamic).reduce((acc, [widgetKey, widget]) => {
+      return { ...acc, [widgetKey]: Widgets.toStatic(widget, sharedSlices) };
+    }, {});
+    return section;
+  }
+};
+
+var Section = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sectionReader: sectionReader,
+  StaticSection: StaticSection,
+  DynamicSection: DynamicSection,
+  Sections: Sections
+});
+
+var index$4 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  BooleanField: BooleanField,
+  Color: Color,
+  Date: Date,
+  GeoPoint: GeoPoint,
+  Image: Image,
+  IntegrationField: IntegrationField,
+  Link: Link,
+  NestableWidget: NestableWidget,
+  Number: Number,
+  Range: Range,
+  RichText: RichText,
+  Select: Select,
+  Separator: Separator,
+  Text: Text,
+  Timestamp: Timestamp
+});
+
+var index$3 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ImageConstraint: ImageConstraint
+});
+
+var Slice = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var index$2 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Slice: Slice,
+  SliceZone: Slices$1,
+  CompositeSlice: CompositeSlice,
+  LegacySlice: LegacySlice,
+  SharedSlice: SharedSlice,
+  SharedSliceRef: SharedSliceRef,
+  SlicesTypes: SlicesTypes$1
+});
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Nestable: index$4,
+  Shared: index$3,
+  Slices: index$2,
+  Widget: Widget,
+  Group: Group,
+  UID: UID,
+  WidgetTypes: WidgetTypes$1
+});
+
+class CustomTypeSlicesError extends Error {
+  constructor(slices) {
+    super();
+    this.slices = slices;
+    this.message = this._formatError(slices);
+  }
+  _formatError(slicesRefs) {
+    const slicesMsg = slicesRefs.map((ref) => `	 - ${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,
+      repeatable: withFallback(t.boolean, true),
+      json: t.record(t.string, sectionReader(format)),
+      status: withFallback(t.boolean, true)
+    }),
+    t.partial({
+      hash: t.string
+    })
+  ]));
+}
+const StaticCustomType = customTypeReader(Format.Static);
+const CustomType = customTypeReader(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.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.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]: Sections.toStatic(dynSection, sharedSlices) };
+  }, {});
+  return { ...customType, json };
+}
+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 left(new CustomTypeSlicesError(missingSlices));
+  else
+    return right(customType);
+}
+function collectWidgets(customType, f) {
+  const json = Object.entries(customType.json).reduce((acc, [sectionId, section]) => {
+    const updatedSection = Object.entries(section).reduce((acc2, [ref, widget]) => {
+      const updatedWidget = f(ref, widget);
+      if (!!updatedWidget) {
+        return { ...acc2, [ref]: updatedWidget };
+      }
+      return acc2;
+    }, {});
+    return { ...acc, [sectionId]: updatedSection };
+  }, {});
+  return { ...customType, json };
+}
+function filterMissingSharedSlices(customType, sharedSlices) {
+  return collectWidgets(customType, (_widgetId, widget) => {
+    if (widget.type === WidgetTypes$1.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.SharedSlice && !sharedSlices.get(sliceId))
+          return acc;
+        return { ...acc, [sliceId]: sliceValue };
+      }, {});
+      const config = { ...widget.config, choices };
+      return { ...widget, config };
+    }
+    return widget;
+  });
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Section: Section,
+  Widgets: index$1,
+  get Format () { return Format; },
+  StaticCustomType: StaticCustomType,
+  CustomType: CustomType,
+  toStatic: toStatic,
+  validateSlices: validateSlices,
+  collectWidgets: collectWidgets,
+  filterMissingSharedSlices: filterMissingSharedSlices
+});
+
+export { index as CustomTypes };
+//# sourceMappingURL=index.js.map