@prismicio/types-internal 0.1.0

package/dist/customtypes/widgets/index.js

@@ -0,0 +1,735 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const t = require('io-ts');
+const Either = require('fp-ts/lib/Either');
+const IntFromString = require('io-ts-types/lib/IntFromString');
+const pipeable = require('fp-ts/lib/pipeable');
+const withFallback = require('io-ts-types/lib/withFallback');
+const NumberFromString = require('io-ts-types/lib/NumberFromString');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () {
+            return e[k];
+          }
+        });
+      }
+    });
+  }
+  n['default'] = e;
+  return Object.freeze(n);
+}
+
+const t__namespace = /*#__PURE__*/_interopNamespace(t);
+
+const StringOrNull = t__namespace.union([t__namespace.string, t__namespace.null, t__namespace.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 = {}));
+const WidgetTypes$1 = WidgetTypes;
+
+const BooleanConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  default_value: t__namespace.boolean,
+  placeholder_true: t__namespace.string,
+  placeholder_false: t__namespace.string
+}));
+const BooleanField = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.BooleanField)
+  }),
+  t__namespace.partial({
+    config: BooleanConfig
+  })
+]));
+
+const ColorConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string
+}));
+const Color = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Color)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: ColorConfig
+  })
+]));
+
+const DateConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  default: t__namespace.string
+}));
+const Date = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Date)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: DateConfig
+  })
+]));
+
+const GeoPointConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull
+}));
+const GeoPoint = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.GeoPoint)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: GeoPointConfig
+  })
+]));
+
+const IntFromNumber = new t__namespace.Type("IntFromNumber", t__namespace.Int.is, (u, c) => pipeable.pipe(t__namespace.number.validate(u, c), Either.chain((n) => {
+  if (t__namespace.Int.is(n))
+    return t__namespace.success(n);
+  else {
+    return t__namespace.success(Math.round(n));
+  }
+})), t__namespace.Int.encode);
+
+const PixelsRegex = /^([0-9]+)px$/;
+const IntFromPixels = new t__namespace.Type("IntFromPixels", t__namespace.Int.is, (u, c) => pipeable.pipe(t__namespace.string.validate(u, c), Either.chain((strPixels) => {
+  try {
+    const matched = strPixels.match(PixelsRegex);
+    if (!matched)
+      return t__namespace.failure(u, c);
+    else {
+      const parsed = parseInt(matched[1]);
+      return t__namespace.success(parsed);
+    }
+  } catch (e) {
+    return t__namespace.failure(u, c);
+  }
+})), String);
+
+const SideConstraint = new t__namespace.Type("SideConstraints", (u) => {
+  return !u || typeof u === "number";
+}, (u, context) => {
+  return Either.either.chain(t__namespace.union([
+    t__namespace.literal("auto"),
+    t__namespace.literal(""),
+    t__namespace.Int,
+    IntFromString.IntFromString,
+    IntFromNumber,
+    IntFromPixels,
+    t__namespace.null
+  ]).validate(u, context), (constraint) => {
+    if (constraint === "auto" || constraint === "")
+      return t__namespace.success(null);
+    return t__namespace.success(constraint);
+  });
+}, (res) => res);
+const ImageConstraint = t__namespace.partial({
+  width: SideConstraint,
+  height: SideConstraint
+});
+
+const Thumbnail = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    name: t__namespace.string
+  }),
+  ImageConstraint
+]));
+const ImageConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  constraint: ImageConstraint,
+  thumbnails: t__namespace.array(Thumbnail)
+}));
+const Image = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Image)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: ImageConfig
+  })
+]));
+
+const IntegrationFieldConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  catalog: t__namespace.string
+}));
+const IntegrationField = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.IntegrationField)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: IntegrationFieldConfig
+  })
+]));
+
+const arrayString = (entries) => {
+  if (entries instanceof Array) {
+    const isValidEntries = entries.reduce((acc, l) => acc && typeof l === "string", true);
+    if (isValidEntries)
+      return t__namespace.success(entries);
+  }
+};
+const plainString = (entries) => {
+  if (typeof entries === "string") {
+    return t__namespace.success([entries]);
+  }
+};
+const MasksArrayString = new t__namespace.Type("MasksArrayString", (u) => {
+  return u instanceof Array;
+}, (u, context) => {
+  return Either.either.chain(t__namespace.union([
+    t__namespace.array(t__namespace.string),
+    t__namespace.string
+  ]).validate(u, context), (masks) => {
+    return arrayString(masks) || plainString(masks) || t__namespace.failure(u, context);
+  });
+}, (res) => res);
+const LinkConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  useAsTitle: t__namespace.boolean,
+  placeholder: t__namespace.string,
+  select: withFallback.withFallback(t__namespace.union([
+    t__namespace.literal("media"),
+    t__namespace.literal("document"),
+    t__namespace.literal("web"),
+    t__namespace.null
+  ]), null),
+  customtypes: t__namespace.array(t__namespace.string),
+  masks: MasksArrayString,
+  tags: MasksArrayString,
+  allowTargetBlank: t__namespace.boolean
+}));
+const Link = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Link)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: LinkConfig
+  })
+]));
+
+const EmbedConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  useAsTitle: t__namespace.boolean
+}));
+const Embed = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Embed)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: EmbedConfig
+  })
+]));
+
+const NumberConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  min: t__namespace.union([t__namespace.number, NumberFromString.NumberFromString]),
+  max: t__namespace.union([t__namespace.number, NumberFromString.NumberFromString]),
+  step: t__namespace.union([t__namespace.number, NumberFromString.NumberFromString])
+}));
+const Number = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Number)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: NumberConfig
+  })
+]));
+
+const RangeConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  min: t__namespace.union([t__namespace.number, NumberFromString.NumberFromString]),
+  max: t__namespace.union([t__namespace.number, NumberFromString.NumberFromString]),
+  step: t__namespace.union([t__namespace.number, NumberFromString.NumberFromString])
+}));
+const Range = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Range)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: RangeConfig
+  })
+]));
+
+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__namespace.Type("RichTextOptions", (u) => typeof u === "string", (u, context) => {
+  return Either.either.chain(t__namespace.union([
+    t__namespace.string,
+    t__namespace.null
+  ]).validate(u, context), (s) => {
+    if (!s)
+      return t__namespace.success(DEFAULT_OPTION);
+    const entries = s.split(",").map((e) => e.trim());
+    const filtered = entries.filter((entry) => options.includes(entry));
+    if (!filtered.length)
+      return t__namespace.success(DEFAULT_OPTION);
+    return t__namespace.success(filtered.join(","));
+  });
+}, (a) => a);
+const NoLabels = (labels) => {
+  if (!labels)
+    return t__namespace.success([]);
+};
+const LabelsAsObject = (labels) => {
+  if (labels instanceof Object) {
+    const labelsObj = labels;
+    if (!Object.entries(labelsObj).length)
+      return t__namespace.success([]);
+    if (labelsObj[""]) {
+      return t__namespace.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__namespace.success(convertedObjectToArray);
+  }
+};
+const LabelsAsArray = (labels) => {
+  if (labels instanceof Array) {
+    const isValidLabels = labels.reduce((acc, l) => acc && typeof l === "string", true);
+    if (isValidLabels)
+      return t__namespace.success(labels);
+  }
+};
+const LabelsAsString = (labels) => {
+  if (typeof labels === "string") {
+    return t__namespace.success([labels]);
+  }
+};
+const RichTextLabels = new t__namespace.Type("RichTextLabels", (u) => {
+  return u instanceof Array;
+}, (u, context) => {
+  const legacyValidator = t__namespace.record(t__namespace.string, t__namespace.array(t__namespace.record(t__namespace.literal("name"), t__namespace.string)));
+  const validator = t__namespace.array(t__namespace.string);
+  return Either.either.chain(t__namespace.union([
+    legacyValidator,
+    validator,
+    t__namespace.string,
+    t__namespace.null
+  ]).validate(u, context), (labels) => {
+    return NoLabels(labels) || LabelsAsArray(labels) || LabelsAsObject(labels) || LabelsAsString(labels) || t__namespace.failure(u, context);
+  });
+}, (res) => res);
+const RichTextConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  useAsTitle: t__namespace.boolean,
+  single: RichTextOptions,
+  multi: RichTextOptions,
+  imageConstraint: ImageConstraint,
+  labels: RichTextLabels,
+  allowTargetBlank: t__namespace.boolean
+}));
+const RichText = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.RichText)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: RichTextConfig
+  })
+]));
+
+const StringFromBoolean = new t__namespace.Type("StringFromInt", t__namespace.string.is, (u, c) => pipeable.pipe(t__namespace.boolean.validate(u, c), Either.chain((i) => {
+  return t__namespace.success(i.toString());
+})), (i) => i);
+
+const StringFromNumber = new t__namespace.Type("StringFromInt", t__namespace.string.is, (u, c) => pipeable.pipe(t__namespace.number.validate(u, c), Either.chain((i) => {
+  return t__namespace.success(i.toString());
+})), (i) => i);
+
+const SelectConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  default_value: t__namespace.string,
+  options: t__namespace.array(t__namespace.union([t__namespace.string, StringFromNumber, StringFromBoolean]))
+}));
+const Select = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Select)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: SelectConfig
+  })
+]));
+
+const SeparatorConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull
+}));
+const Separator = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Separator)
+  }),
+  t__namespace.partial({
+    config: SeparatorConfig
+  })
+]));
+
+const TextConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  useAsTitle: t__namespace.boolean,
+  placeholder: t__namespace.string
+}));
+const Text = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Text)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: TextConfig
+  })
+]));
+
+const TimestampConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  placeholder: t__namespace.string,
+  default: t__namespace.string
+}));
+const Timestamp = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Timestamp)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: TimestampConfig
+  })
+]));
+
+const NestableWidget = t__namespace.union([
+  Color,
+  BooleanField,
+  Embed,
+  GeoPoint,
+  Date,
+  Number,
+  Range,
+  RichText,
+  Select,
+  Separator,
+  Text,
+  Timestamp,
+  Link,
+  Image,
+  IntegrationField
+]);
+
+const index$2 = /*#__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
+});
+
+const index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ImageConstraint: ImageConstraint
+});
+
+var SlicesTypes;
+(function(SlicesTypes2) {
+  SlicesTypes2["Slice"] = "Slice";
+  SlicesTypes2["SharedSlice"] = "SharedSlice";
+})(SlicesTypes || (SlicesTypes = {}));
+const SlicesTypes$1 = SlicesTypes;
+
+const CompositeSliceConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull
+}));
+const CompositeSlice = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(SlicesTypes$1.Slice)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    description: t__namespace.string,
+    icon: t__namespace.string,
+    display: t__namespace.string,
+    "non-repeat": t__namespace.record(t__namespace.string, NestableWidget),
+    repeat: t__namespace.record(t__namespace.string, NestableWidget),
+    config: CompositeSliceConfig
+  })
+]));
+
+const UIDConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  useAsTitle: t__namespace.boolean,
+  placeholder: t__namespace.string
+}));
+const UID = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.UID)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    config: UIDConfig
+  })
+]));
+
+const GroupConfig = t__namespace.exact(t__namespace.partial({
+  label: StringOrNull,
+  repeat: t__namespace.boolean,
+  fields: t__namespace.record(t__namespace.string, NestableWidget)
+}));
+const Group = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    type: t__namespace.literal(WidgetTypes$1.Group)
+  }),
+  t__namespace.partial({
+    fieldset: StringOrNull,
+    icon: t__namespace.string,
+    description: t__namespace.string,
+    config: GroupConfig
+  })
+]));
+
+const LegacySlice = t__namespace.union([
+  UID,
+  NestableWidget,
+  Group
+]);
+
+const IMAGE_PLACEHOLDER_URL = "https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format";
+const Variation = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    id: t__namespace.string,
+    name: t__namespace.string,
+    description: t__namespace.string,
+    imageUrl: withFallback.withFallback(t__namespace.string, IMAGE_PLACEHOLDER_URL),
+    docURL: t__namespace.string,
+    version: t__namespace.string
+  }),
+  t__namespace.partial({
+    display: t__namespace.string,
+    primary: t__namespace.record(t__namespace.string, NestableWidget),
+    items: t__namespace.record(t__namespace.string, NestableWidget)
+  })
+]));
+const SharedSlice = t__namespace.exact(t__namespace.intersection([
+  t__namespace.type({
+    id: t__namespace.string,
+    type: t__namespace.literal(SlicesTypes$1.SharedSlice),
+    name: t__namespace.string,
+    variations: t__namespace.array(Variation)
+  }),
+  t__namespace.partial({
+    description: t__namespace.string
+  })
+]));
+
+const SharedSliceRef = t__namespace.exact(t__namespace.type({
+  type: t__namespace.literal(SlicesTypes$1.SharedSlice)
+}));
+
+const Slice = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+var Format;
+(function(Format2) {
+  Format2["Static"] = "static";
+  Format2["Dynamic"] = "dynamic";
+})(Format || (Format = {}));
+
+const SlicesLabels = t__namespace.union([
+  t__namespace.record(t__namespace.string, t__namespace.array(t__namespace.exact(t__namespace.intersection([
+    t__namespace.type({
+      name: t__namespace.string
+    }),
+    t__namespace.partial({
+      display: t__namespace.string
+    })
+  ])))),
+  t__namespace.null
+]);
+function slicesConfigReader(format) {
+  return t__namespace.exact(t__namespace.partial({
+    label: StringOrNull,
+    labels: SlicesLabels,
+    choices: t__namespace.record(t__namespace.string, t__namespace.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__namespace.exact(t__namespace.intersection([
+    t__namespace.type({
+      type: t__namespace.union([t__namespace.literal(WidgetTypes$1.Slices), t__namespace.literal(WidgetTypes$1.LegacySlices)])
+    }),
+    t__namespace.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) };
+    }
+  }
+};
+
+const Slices$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  slicesConfigReader: slicesConfigReader,
+  StaticSlicesConfig: StaticSlicesConfig,
+  DynamicSlicesConfig: DynamicSlicesConfig,
+  slicesReader: slicesReader,
+  StaticSlices: StaticSlices,
+  DynamicSlices: DynamicSlices,
+  Slices: Slices
+});
+
+const index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Slice: Slice,
+  SliceZone: Slices$1,
+  CompositeSlice: CompositeSlice,
+  LegacySlice: LegacySlice,
+  SharedSlice: SharedSlice,
+  SharedSliceRef: SharedSliceRef,
+  SlicesTypes: SlicesTypes$1
+});
+
+function widgetReader(format) {
+  return t__namespace.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;
+    }
+  }
+};
+
+const Widget = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  widgetReader: widgetReader,
+  StaticWidget: StaticWidget,
+  DynamicWidget: DynamicWidget,
+  Widgets: Widgets
+});
+
+exports.Group = Group;
+exports.Nestable = index$2;
+exports.Shared = index$1;
+exports.Slices = index;
+exports.UID = UID;
+exports.Widget = Widget;
+exports.WidgetTypes = WidgetTypes$1;
+//# sourceMappingURL=index.js.map