@prismicio/types-internal 3.17.0-alpha.2 → 3.17.0-pr.144.0c8207f

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

@@ -0,0 +1,462 @@
+import { OnFieldFn } from "../../../utils/Fields.js";
+import "../../../utils/index.js";
+import { NestableWidget } from "../nestable/NestableWidget.js";
+import { DynamicSlice, StaticSlice } from "./Slice.js";
+import * as t from "io-ts";
+import * as io_ts_types0 from "io-ts-types";
+
+//#region src/customtypes/widgets/slices/CompositeSlice.d.ts
+declare const CompositeSliceType = "Slice";
+declare const CompositeSliceConfig: t.ExactC<t.PartialC<{
+  label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>>;
+type CompositeSliceConfig = t.TypeOf<typeof CompositeSliceConfig>;
+declare const CompositeSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
+  type: t.LiteralC<"Slice">;
+}>, t.PartialC<{
+  fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+  description: t.StringC;
+  icon: t.StringC;
+  display: t.StringC;
+  "non-repeat": t.RecordC<t.Type<string, string, unknown>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Color">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Boolean">;
+  }>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      default_value: t.BooleanC;
+      placeholder_true: t.StringC;
+      placeholder_false: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Embed">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      useAsTitle: t.BooleanC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"GeoPoint">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Date">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      default: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Number">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      min: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      max: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      step: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Range">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      min: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      max: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      step: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"StructuredText">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      useAsTitle: t.BooleanC;
+      single: t.Type<string, string, unknown>;
+      multi: t.Type<string, string, unknown>;
+      imageConstraint: t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+      }>;
+      labels: t.Type<readonly string[], object, unknown>;
+      allowTargetBlank: t.BooleanC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Select">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      default_value: t.StringC;
+      options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Separator">;
+  }>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Table">;
+  }>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Text">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      useAsTitle: t.BooleanC;
+      placeholder: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      default: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Link">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      useAsTitle: t.BooleanC;
+      placeholder: t.StringC;
+      select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+      customtypes: t.Type<readonly (string | {
+        id: string;
+        fields: readonly (string | {
+          id: string;
+          customtypes: readonly (string | {
+            id: string;
+            fields: readonly (string | {
+              id: string;
+              fields: readonly string[];
+            })[];
+          })[];
+        } | {
+          id: string;
+          fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+              id: string;
+              fields: readonly (string | {
+                id: string;
+                fields: readonly string[];
+              })[];
+            })[];
+          })[];
+        })[];
+      })[], readonly (string | {
+        id: string;
+        fields: readonly (string | {
+          id: string;
+          customtypes: readonly (string | {
+            id: string;
+            fields: readonly (string | {
+              id: string;
+              fields: readonly string[];
+            })[];
+          })[];
+        } | {
+          id: string;
+          fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+              id: string;
+              fields: readonly (string | {
+                id: string;
+                fields: readonly string[];
+              })[];
+            })[];
+          })[];
+        })[];
+      })[], unknown>;
+      masks: t.Type<readonly string[], object, unknown>;
+      tags: t.Type<readonly string[], object, unknown>;
+      allowTargetBlank: t.BooleanC;
+      allowText: t.BooleanC;
+      repeat: t.BooleanC;
+      variants: t.ArrayC<t.StringC>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Image">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      constraint: t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+      }>;
+      thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+        name: t.StringC;
+      }>, t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+      }>]>>>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"IntegrationFields">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      catalog: t.StringC;
+    }>>;
+  }>]>>]>>;
+  repeat: t.RecordC<t.Type<string, string, unknown>, t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Color">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Boolean">;
+  }>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      default_value: t.BooleanC;
+      placeholder_true: t.StringC;
+      placeholder_false: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Embed">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      useAsTitle: t.BooleanC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"GeoPoint">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Date">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      default: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Number">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      min: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      max: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      step: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Range">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      min: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      max: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+      step: t.UnionC<[t.NumberC, io_ts_types0.NumberFromStringC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"StructuredText">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      useAsTitle: t.BooleanC;
+      single: t.Type<string, string, unknown>;
+      multi: t.Type<string, string, unknown>;
+      imageConstraint: t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+      }>;
+      labels: t.Type<readonly string[], object, unknown>;
+      allowTargetBlank: t.BooleanC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Select">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      default_value: t.StringC;
+      options: t.ReadonlyArrayC<t.UnionC<[t.StringC, t.Type<string, string, unknown>, t.Type<string, string, unknown>]>>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Separator">;
+  }>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Table">;
+  }>, t.PartialC<{
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Text">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      useAsTitle: t.BooleanC;
+      placeholder: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Timestamp">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      default: t.StringC;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Link">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      useAsTitle: t.BooleanC;
+      placeholder: t.StringC;
+      select: t.UnionC<[t.LiteralC<"media">, t.LiteralC<"document">, t.LiteralC<"web">, t.NullC]>;
+      customtypes: t.Type<readonly (string | {
+        id: string;
+        fields: readonly (string | {
+          id: string;
+          customtypes: readonly (string | {
+            id: string;
+            fields: readonly (string | {
+              id: string;
+              fields: readonly string[];
+            })[];
+          })[];
+        } | {
+          id: string;
+          fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+              id: string;
+              fields: readonly (string | {
+                id: string;
+                fields: readonly string[];
+              })[];
+            })[];
+          })[];
+        })[];
+      })[], readonly (string | {
+        id: string;
+        fields: readonly (string | {
+          id: string;
+          customtypes: readonly (string | {
+            id: string;
+            fields: readonly (string | {
+              id: string;
+              fields: readonly string[];
+            })[];
+          })[];
+        } | {
+          id: string;
+          fields: readonly (string | {
+            id: string;
+            customtypes: readonly (string | {
+              id: string;
+              fields: readonly (string | {
+                id: string;
+                fields: readonly string[];
+              })[];
+            })[];
+          })[];
+        })[];
+      })[], unknown>;
+      masks: t.Type<readonly string[], object, unknown>;
+      tags: t.Type<readonly string[], object, unknown>;
+      allowTargetBlank: t.BooleanC;
+      allowText: t.BooleanC;
+      repeat: t.BooleanC;
+      variants: t.ArrayC<t.StringC>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"Image">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      constraint: t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+      }>;
+      thumbnails: t.ReadonlyArrayC<t.ExactC<t.IntersectionC<[t.TypeC<{
+        name: t.StringC;
+      }>, t.PartialC<{
+        width: t.Type<number | null, unknown, unknown>;
+        height: t.Type<number | null, unknown, unknown>;
+      }>]>>>;
+    }>>;
+  }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"IntegrationFields">;
+  }>, t.PartialC<{
+    fieldset: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    config: t.ExactC<t.PartialC<{
+      label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+      placeholder: t.StringC;
+      catalog: t.StringC;
+    }>>;
+  }>]>>]>>;
+  config: t.ExactC<t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+  }>>;
+}>]>>;
+type CompositeSlice = t.TypeOf<typeof CompositeSlice>;
+declare function isCompositeSlice(slice: DynamicSlice | StaticSlice): slice is CompositeSlice;
+declare function traverseCompositeSlice(args: {
+  path: ReadonlyArray<string>;
+  slice: CompositeSlice;
+  onField: OnFieldFn<NestableWidget>;
+}): CompositeSlice;
+//#endregion
+export { CompositeSlice, CompositeSliceConfig, CompositeSliceType, isCompositeSlice, traverseCompositeSlice };
+//# sourceMappingURL=CompositeSlice.d.ts.map

package/dist/customtypes/widgets/slices/CompositeSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeSlice.d.ts","names":[],"sources":["../../../../src/customtypes/widgets/slices/CompositeSlice.ts"],"mappings":";;;;;;;;cAQa,kBAAA;AAAA,cAEA,oBAAA,EAAoB,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,QAAA;;;KAKrB,oBAAA,GAAuB,CAAA,CAAE,MAAA,QAAc,oBAAA;AAAA,cAEtC,cAAA,EAAc,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,aAAA,EAAA,CAAA,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgBf,cAAA,GAAiB,CAAA,CAAE,MAAA,QAAc,cAAA;AAAA,iBAE7B,gBAAA,CAAiB,KAAA,EAAO,YAAA,GAAe,WAAA,GAAc,KAAA,IAAS,cAAA;AAAA,iBAI9D,sBAAA,CAAuB,IAAA;EACtC,IAAA,EAAM,aAAA;EACN,KAAA,EAAO,cAAA;EACP,OAAA,EAAS,SAAA,CAAiB,cAAA;AAAA,IACvB,cAAA"}

package/dist/customtypes/widgets/slices/CompositeSlice.js

@@ -0,0 +1,66 @@
+import { WidgetKey } from "../../../common/WidgetKey.js";
+import "../../../common/index.js";
+import StringOrNull_default from "../../../validators/StringOrNull.js";
+import "../../../validators/index.js";
+import { NestableWidget } from "../nestable/NestableWidget.js";
+import * as t from "io-ts";
+
+//#region src/customtypes/widgets/slices/CompositeSlice.ts
+const CompositeSliceType = "Slice";
+const CompositeSliceConfig = t.exact(t.partial({ label: StringOrNull_default }));
+const CompositeSlice = t.exact(t.intersection([t.type({ type: t.literal(CompositeSliceType) }), t.partial({
+	fieldset: StringOrNull_default,
+	description: t.string,
+	icon: t.string,
+	display: t.string,
+	"non-repeat": t.record(WidgetKey, NestableWidget),
+	repeat: t.record(WidgetKey, NestableWidget),
+	config: CompositeSliceConfig
+})]));
+function isCompositeSlice(slice) {
+	return slice.type === "Slice";
+}
+function traverseCompositeSlice(args) {
+	const { path: prevPath, slice, onField } = args;
+	let nonRepeat;
+	for (const [key, field] of Object.entries(slice["non-repeat"] ?? {})) {
+		const newField = onField({
+			path: [
+				...prevPath,
+				"non-repeat",
+				key
+			],
+			key,
+			field
+		});
+		if (field !== newField) {
+			if (!nonRepeat) nonRepeat = { ...slice["non-repeat"] };
+			nonRepeat[key] = newField;
+		}
+	}
+	let repeat;
+	for (const [key, field] of Object.entries(slice.repeat ?? {})) {
+		const newField = onField({
+			path: [
+				...prevPath,
+				"repeat",
+				key
+			],
+			key,
+			field
+		});
+		if (field !== newField) {
+			if (!repeat) repeat = { ...slice.repeat };
+			repeat[key] = newField;
+		}
+	}
+	return repeat || nonRepeat ? {
+		...slice,
+		...nonRepeat && { "non-repeat": nonRepeat },
+		...repeat && { repeat }
+	} : slice;
+}
+
+//#endregion
+export { CompositeSlice, CompositeSliceConfig, CompositeSliceType, isCompositeSlice, traverseCompositeSlice };
+//# sourceMappingURL=CompositeSlice.js.map

package/dist/customtypes/widgets/slices/CompositeSlice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeSlice.js","names":["StringOrNull"],"sources":["../../../../src/customtypes/widgets/slices/CompositeSlice.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { WidgetKey } from \"../../../common\"\nimport type { Fields } from \"../../../utils\"\nimport { StringOrNull } from \"../../../validators\"\nimport { NestableWidget } from \"../nestable/NestableWidget\"\nimport type { DynamicSlice, StaticSlice } from \"./Slice\"\n\nexport const CompositeSliceType = \"Slice\"\n\nexport const CompositeSliceConfig = t.exact(\n\tt.partial({\n\t\tlabel: StringOrNull,\n\t}),\n)\nexport type CompositeSliceConfig = t.TypeOf<typeof CompositeSliceConfig>\n\nexport const CompositeSlice = t.exact(\n\tt.intersection([\n\t\tt.type({\n\t\t\ttype: t.literal(CompositeSliceType),\n\t\t}),\n\t\tt.partial({\n\t\t\tfieldset: StringOrNull,\n\t\t\tdescription: t.string,\n\t\t\ticon: t.string,\n\t\t\tdisplay: t.string,\n\t\t\t\"non-repeat\": t.record(WidgetKey, NestableWidget),\n\t\t\trepeat: t.record(WidgetKey, NestableWidget),\n\t\t\tconfig: CompositeSliceConfig,\n\t\t}),\n\t]),\n)\nexport type CompositeSlice = t.TypeOf<typeof CompositeSlice>\n\nexport function isCompositeSlice(slice: DynamicSlice | StaticSlice): slice is CompositeSlice {\n\treturn slice.type === \"Slice\"\n}\n\nexport function traverseCompositeSlice(args: {\n\tpath: ReadonlyArray<string>\n\tslice: CompositeSlice\n\tonField: Fields.OnFieldFn<NestableWidget>\n}): CompositeSlice {\n\tconst { path: prevPath, slice, onField } = args\n\n\tlet nonRepeat: Record<string, NestableWidget> | undefined\n\tfor (const [key, field] of Object.entries(slice[\"non-repeat\"] ?? {})) {\n\t\tconst path = [...prevPath, \"non-repeat\", key]\n\t\tconst newField = onField({ path, key, field })\n\n\t\tif (field !== newField) {\n\t\t\tif (!nonRepeat) nonRepeat = { ...slice[\"non-repeat\"] }\n\t\t\tnonRepeat[key] = newField\n\t\t}\n\t}\n\n\tlet repeat: Record<string, NestableWidget> | undefined\n\tfor (const [key, field] of Object.entries(slice.repeat ?? {})) {\n\t\tconst path = [...prevPath, \"repeat\", key]\n\t\tconst newField = onField({ path, key, field })\n\n\t\tif (field !== newField) {\n\t\t\tif (!repeat) repeat = { ...slice.repeat }\n\t\t\trepeat[key] = newField\n\t\t}\n\t}\n\n\t// returns the traversed model instead of a new one if it didn't change\n\treturn repeat || nonRepeat\n\t\t? {\n\t\t\t\t...slice,\n\t\t\t\t...(nonRepeat && { \"non-repeat\": nonRepeat }),\n\t\t\t\t...(repeat && { repeat }),\n\t\t\t}\n\t\t: slice\n}\n"],"mappings":";;;;;;;;AAQA,MAAa,qBAAqB;AAElC,MAAa,uBAAuB,EAAE,MACrC,EAAE,QAAQ,EACT,OAAOA,sBACP,CAAC,CACF;AAGD,MAAa,iBAAiB,EAAE,MAC/B,EAAE,aAAa,CACd,EAAE,KAAK,EACN,MAAM,EAAE,QAAQ,mBAAmB,EACnC,CAAC,EACF,EAAE,QAAQ;CACT,UAAUA;CACV,aAAa,EAAE;CACf,MAAM,EAAE;CACR,SAAS,EAAE;CACX,cAAc,EAAE,OAAO,WAAW,eAAe;CACjD,QAAQ,EAAE,OAAO,WAAW,eAAe;CAC3C,QAAQ;CACR,CAAC,CACF,CAAC,CACF;AAGD,SAAgB,iBAAiB,OAA4D;AAC5F,QAAO,MAAM,SAAS;;AAGvB,SAAgB,uBAAuB,MAIpB;CAClB,MAAM,EAAE,MAAM,UAAU,OAAO,YAAY;CAE3C,IAAI;AACJ,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,iBAAiB,EAAE,CAAC,EAAE;EAErE,MAAM,WAAW,QAAQ;GAAE,MADd;IAAC,GAAG;IAAU;IAAc;IAAI;GACZ;GAAK;GAAO,CAAC;AAE9C,MAAI,UAAU,UAAU;AACvB,OAAI,CAAC,UAAW,aAAY,EAAE,GAAG,MAAM,eAAe;AACtD,aAAU,OAAO;;;CAInB,IAAI;AACJ,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,UAAU,EAAE,CAAC,EAAE;EAE9D,MAAM,WAAW,QAAQ;GAAE,MADd;IAAC,GAAG;IAAU;IAAU;IAAI;GACR;GAAK;GAAO,CAAC;AAE9C,MAAI,UAAU,UAAU;AACvB,OAAI,CAAC,OAAQ,UAAS,EAAE,GAAG,MAAM,QAAQ;AACzC,UAAO,OAAO;;;AAKhB,QAAO,UAAU,YACd;EACA,GAAG;EACH,GAAI,aAAa,EAAE,cAAc,WAAW;EAC5C,GAAI,UAAU,EAAE,QAAQ;EACxB,GACA"}

package/dist/customtypes/widgets/slices/LegacySlice.cjs

@@ -0,0 +1,16 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
+const require_NestableWidget = require('../nestable/NestableWidget.cjs');
+const require_Group = require('../Group.cjs');
+let io_ts = require("io-ts");
+io_ts = require_runtime.__toESM(io_ts);
+
+//#region src/customtypes/widgets/slices/LegacySlice.ts
+const LegacySlice = io_ts.union([require_NestableWidget.NestableWidget, require_Group.NestedGroup]);
+function isLegacySlice(slice) {
+	return slice.type !== "Slice" && slice.type !== "SharedSlice";
+}
+
+//#endregion
+exports.LegacySlice = LegacySlice;
+exports.isLegacySlice = isLegacySlice;
+//# sourceMappingURL=LegacySlice.cjs.map

package/dist/customtypes/widgets/slices/LegacySlice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegacySlice.cjs","names":["t","NestableWidget","NestedGroup"],"sources":["../../../../src/customtypes/widgets/slices/LegacySlice.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { NestedGroup } from \"../Group\"\nimport { NestableWidget } from \"../nestable/NestableWidget\"\nimport type { DynamicSlice, StaticSlice } from \"./Slice\"\n\nexport const LegacySlice = t.union([NestableWidget, NestedGroup])\n\nexport type LegacySlice = t.TypeOf<typeof LegacySlice>\n\nexport function isLegacySlice(slice: DynamicSlice | StaticSlice): slice is LegacySlice {\n\treturn slice.type !== \"Slice\" && slice.type !== \"SharedSlice\"\n}\n"],"mappings":";;;;;;;AAMA,MAAa,cAAcA,MAAE,MAAM,CAACC,uCAAgBC,0BAAY,CAAC;AAIjE,SAAgB,cAAc,OAAyD;AACtF,QAAO,MAAM,SAAS,WAAW,MAAM,SAAS"}