@usethrottle/builder-schema 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.cjs +228 -224
  2. package/dist/index.js +228 -224
  3. package/package.json +6 -2
package/dist/index.cjs CHANGED
@@ -125,6 +125,10 @@ __export(index_exports, {
125
125
  });
126
126
  module.exports = __toCommonJS(index_exports);
127
127
 
128
+ // src/jitless.ts
129
+ var import_zod = require("zod");
130
+ import_zod.z.config({ jitless: true });
131
+
128
132
  // src/ids.ts
129
133
  var NODE_ID_RE = /^[a-z0-9]{8,24}$/;
130
134
  var ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -255,7 +259,7 @@ function dropShadowed(issues) {
255
259
  }
256
260
 
257
261
  // src/document.ts
258
- var import_zod3 = require("zod");
262
+ var import_zod4 = require("zod");
259
263
 
260
264
  // src/walk.ts
261
265
  function walkNodes(doc, visit) {
@@ -430,7 +434,7 @@ function checkLimits(doc) {
430
434
  }
431
435
 
432
436
  // src/site-settings.ts
433
- var import_zod2 = require("zod");
437
+ var import_zod3 = require("zod");
434
438
 
435
439
  // src/fonts.ts
436
440
  var WEIGHTS_100_900 = [100, 200, 300, 400, 500, 600, 700, 800, 900];
@@ -487,7 +491,7 @@ var SITE_FONTS = FONT_DEFINITIONS;
487
491
  var SITE_FONT_FAMILIES = FONT_DEFINITIONS.map((f) => f.family);
488
492
 
489
493
  // src/safe.ts
490
- var import_zod = require("zod");
494
+ var import_zod2 = require("zod");
491
495
  var customIssue = (ctx, code, message, path = []) => {
492
496
  ctx.addIssue({ code: "custom", message, path, params: { code } });
493
497
  };
@@ -496,8 +500,8 @@ var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
496
500
  "constructor",
497
501
  "prototype"
498
502
  ]);
499
- function safeRecord(value, keySchema = import_zod.z.string().max(64)) {
500
- return import_zod.z.preprocess((input, ctx) => {
503
+ function safeRecord(value, keySchema = import_zod2.z.string().max(64)) {
504
+ return import_zod2.z.preprocess((input, ctx) => {
501
505
  if (typeof input === "object" && input !== null && !Array.isArray(input)) {
502
506
  for (const key of Object.getOwnPropertyNames(input)) {
503
507
  if (FORBIDDEN_KEYS.has(key)) {
@@ -511,7 +515,7 @@ function safeRecord(value, keySchema = import_zod.z.string().max(64)) {
511
515
  }
512
516
  }
513
517
  return input;
514
- }, import_zod.z.record(keySchema, value));
518
+ }, import_zod2.z.record(keySchema, value));
515
519
  }
516
520
 
517
521
  // src/strings.ts
@@ -585,31 +589,31 @@ var CATALOG_STRING_KEYS = [
585
589
 
586
590
  // src/site-settings.ts
587
591
  var LOCALE_TAG_RE = /^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/;
588
- var localeTagSchema = import_zod2.z.string().regex(LOCALE_TAG_RE);
589
- var localizedTextSchema = safeRecord(import_zod2.z.string().max(2e3), localeTagSchema);
590
- var assetIdSchema = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
592
+ var localeTagSchema = import_zod3.z.string().regex(LOCALE_TAG_RE);
593
+ var localizedTextSchema = safeRecord(import_zod3.z.string().max(2e3), localeTagSchema);
594
+ var assetIdSchema = import_zod3.z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
591
595
  var THROTTLE_PK_RE = /^pk_[a-z0-9]+_[A-Za-z0-9]{8,}$/;
592
596
  var SAFE_HREF = (
593
597
  // eslint-disable-next-line no-control-regex
594
598
  /^(?:https?:\/\/[^\s\\\u0000-\u001F\u007F]+|\/(?![/\\])[^\s\\\u0000-\u001F\u007F]*)$/iu
595
599
  );
596
600
  var ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
597
- var menuTargetSchema = import_zod2.z.discriminatedUnion("kind", [
598
- import_zod2.z.object({ kind: import_zod2.z.literal("page"), id: import_zod2.z.string().regex(ULID_RE) }).strict(),
599
- import_zod2.z.object({ kind: import_zod2.z.literal("category"), id: import_zod2.z.string().min(1).max(64) }).strict(),
600
- import_zod2.z.object({ kind: import_zod2.z.literal("collection"), id: import_zod2.z.string().min(1).max(64) }).strict(),
601
- import_zod2.z.object({ kind: import_zod2.z.literal("product"), id: import_zod2.z.string().min(1).max(64) }).strict(),
602
- import_zod2.z.object({
603
- kind: import_zod2.z.literal("search"),
604
- q: import_zod2.z.string().min(1).max(200).regex(/^[^\u0000-\u001F\u007F]+$/u)
601
+ var menuTargetSchema = import_zod3.z.discriminatedUnion("kind", [
602
+ import_zod3.z.object({ kind: import_zod3.z.literal("page"), id: import_zod3.z.string().regex(ULID_RE) }).strict(),
603
+ import_zod3.z.object({ kind: import_zod3.z.literal("category"), id: import_zod3.z.string().min(1).max(64) }).strict(),
604
+ import_zod3.z.object({ kind: import_zod3.z.literal("collection"), id: import_zod3.z.string().min(1).max(64) }).strict(),
605
+ import_zod3.z.object({ kind: import_zod3.z.literal("product"), id: import_zod3.z.string().min(1).max(64) }).strict(),
606
+ import_zod3.z.object({
607
+ kind: import_zod3.z.literal("search"),
608
+ q: import_zod3.z.string().min(1).max(200).regex(/^[^\u0000-\u001F\u007F]+$/u)
605
609
  }).strict(),
606
- import_zod2.z.object({
607
- kind: import_zod2.z.literal("url"),
608
- href: import_zod2.z.string().max(2e3).regex(SAFE_HREF)
610
+ import_zod3.z.object({
611
+ kind: import_zod3.z.literal("url"),
612
+ href: import_zod3.z.string().max(2e3).regex(SAFE_HREF)
609
613
  }).strict()
610
614
  ]);
611
615
  var itemBase = { label: localizedTextSchema, target: menuTargetSchema };
612
- var menuItemLevel3 = import_zod2.z.object({ ...itemBase, children: import_zod2.z.array(import_zod2.z.unknown()).optional() }).strict().superRefine((item, ctx) => {
616
+ var menuItemLevel3 = import_zod3.z.object({ ...itemBase, children: import_zod3.z.array(import_zod3.z.unknown()).optional() }).strict().superRefine((item, ctx) => {
613
617
  if (item.children !== void 0 && item.children.length > 0) {
614
618
  customIssue(
615
619
  ctx,
@@ -619,8 +623,8 @@ var menuItemLevel3 = import_zod2.z.object({ ...itemBase, children: import_zod2.z
619
623
  );
620
624
  }
621
625
  });
622
- var menuItemLevel2 = import_zod2.z.object({ ...itemBase, children: import_zod2.z.array(menuItemLevel3).optional() }).strict();
623
- var menuItemLevel1 = import_zod2.z.object({ ...itemBase, children: import_zod2.z.array(menuItemLevel2).optional() }).strict();
626
+ var menuItemLevel2 = import_zod3.z.object({ ...itemBase, children: import_zod3.z.array(menuItemLevel3).optional() }).strict();
627
+ var menuItemLevel1 = import_zod3.z.object({ ...itemBase, children: import_zod3.z.array(menuItemLevel2).optional() }).strict();
624
628
  var menuItemSchema = menuItemLevel1;
625
629
  function countItems(items) {
626
630
  let count = 0;
@@ -630,7 +634,7 @@ function countItems(items) {
630
634
  }
631
635
  return count;
632
636
  }
633
- var menuSchema = import_zod2.z.array(menuItemSchema).superRefine((items, ctx) => {
637
+ var menuSchema = import_zod3.z.array(menuItemSchema).superRefine((items, ctx) => {
634
638
  if (countItems(items) > LIMITS.menuItems) {
635
639
  customIssue(
636
640
  ctx,
@@ -640,7 +644,7 @@ var menuSchema = import_zod2.z.array(menuItemSchema).superRefine((items, ctx) =>
640
644
  }
641
645
  });
642
646
  var MENU_NAME_RE = /^[a-z][a-z0-9-]{0,39}$/;
643
- var menusSchema = import_zod2.z.object({
647
+ var menusSchema = import_zod3.z.object({
644
648
  header: menuSchema.default(() => []),
645
649
  footer: menuSchema.default(() => [])
646
650
  }).catchall(menuSchema).superRefine((menus, ctx) => {
@@ -660,8 +664,8 @@ var menusSchema = import_zod2.z.object({
660
664
  );
661
665
  }
662
666
  });
663
- var colour = import_zod2.z.string().regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/u);
664
- var paletteSchema = import_zod2.z.object({
667
+ var colour = import_zod3.z.string().regex(/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/u);
668
+ var paletteSchema = import_zod3.z.object({
665
669
  colorPrimary: colour,
666
670
  colorPrimaryForeground: colour,
667
671
  colorBackground: colour,
@@ -709,58 +713,58 @@ var defaultDark = () => ({
709
713
  colorWarning: "#fbbf24",
710
714
  colorDanger: "#f87171"
711
715
  });
712
- var fontFamily = import_zod2.z.enum(SITE_FONT_FAMILIES);
713
- var themeSchema = import_zod2.z.object({
714
- preset: import_zod2.z.enum(["clean", "editorial", "bold"]).default("clean"),
716
+ var fontFamily = import_zod3.z.enum(SITE_FONT_FAMILIES);
717
+ var themeSchema = import_zod3.z.object({
718
+ preset: import_zod3.z.enum(["clean", "editorial", "bold"]).default("clean"),
715
719
  // When false the preset's tokens apply, when true the merchant's values do.
716
- customized: import_zod2.z.boolean().default(false),
720
+ customized: import_zod3.z.boolean().default(false),
717
721
  light: paletteSchema.default(defaultLight),
718
722
  dark: paletteSchema.default(defaultDark),
719
- fonts: import_zod2.z.object({
723
+ fonts: import_zod3.z.object({
720
724
  heading: fontFamily.default("system-sans"),
721
725
  body: fontFamily.default("system-sans"),
722
726
  mono: fontFamily.default("system-mono")
723
727
  }).strict().prefault({}),
724
- radius: import_zod2.z.number().int().min(0).max(32).default(8),
725
- spacingScale: import_zod2.z.enum(["compact", "comfortable", "roomy"]).default("comfortable"),
726
- colorScheme: import_zod2.z.enum(["light", "dark", "auto"]).default("auto")
728
+ radius: import_zod3.z.number().int().min(0).max(32).default(8),
729
+ spacingScale: import_zod3.z.enum(["compact", "comfortable", "roomy"]).default("comfortable"),
730
+ colorScheme: import_zod3.z.enum(["light", "dark", "auto"]).default("auto")
727
731
  }).strict();
728
- var brandSchema = import_zod2.z.object({
729
- storeName: import_zod2.z.string().max(100).regex(/^[^\u0000-\u001F\u007F]*$/u).default(""),
730
- logo: import_zod2.z.object({
732
+ var brandSchema = import_zod3.z.object({
733
+ storeName: import_zod3.z.string().max(100).regex(/^[^\u0000-\u001F\u007F]*$/u).default(""),
734
+ logo: import_zod3.z.object({
731
735
  light: assetIdSchema.nullable().default(null),
732
736
  dark: assetIdSchema.nullable().default(null)
733
737
  }).strict().prefault({}),
734
738
  favicon: assetIdSchema.nullable().default(null)
735
739
  }).strict();
736
- var isoInstant = import_zod2.z.iso.datetime({ offset: true });
737
- var announcementSchema = import_zod2.z.object({
738
- enabled: import_zod2.z.boolean().default(false),
740
+ var isoInstant = import_zod3.z.iso.datetime({ offset: true });
741
+ var announcementSchema = import_zod3.z.object({
742
+ enabled: import_zod3.z.boolean().default(false),
739
743
  message: localizedTextSchema.default({}),
740
744
  target: menuTargetSchema.nullable().default(null),
741
745
  startsAt: isoInstant.nullable().default(null),
742
746
  endsAt: isoInstant.nullable().default(null)
743
747
  }).strict();
744
- var seoSchema = import_zod2.z.object({
745
- titleTemplate: import_zod2.z.string().min(1).max(200).default("{page} \u2013 {store}"),
748
+ var seoSchema = import_zod3.z.object({
749
+ titleTemplate: import_zod3.z.string().min(1).max(200).default("{page} \u2013 {store}"),
746
750
  defaultDescription: localizedTextSchema.default({}),
747
751
  shareImage: assetIdSchema.nullable().default(null)
748
752
  }).strict();
749
- var stringsSchema = import_zod2.z.object(
753
+ var stringsSchema = import_zod3.z.object(
750
754
  Object.fromEntries(
751
755
  SITE_STRING_KEYS.map((key) => [key, localizedTextSchema.optional()])
752
756
  )
753
757
  ).strict();
754
- var routesSchema = import_zod2.z.object({
755
- page: import_zod2.z.string().max(200).regex(/^\/(?!\/)[^\s\\]*\{handle\}[^\s\\]*$/).default("/pages/{handle}"),
756
- home: import_zod2.z.literal("/").default("/")
758
+ var routesSchema = import_zod3.z.object({
759
+ page: import_zod3.z.string().max(200).regex(/^\/(?!\/)[^\s\\]*\{handle\}[^\s\\]*$/).default("/pages/{handle}"),
760
+ home: import_zod3.z.literal("/").default("/")
757
761
  }).strict();
758
- var connectionsSchema = import_zod2.z.object({
759
- throttlePublishableKey: import_zod2.z.string().regex(THROTTLE_PK_RE).nullable().default(null)
762
+ var connectionsSchema = import_zod3.z.object({
763
+ throttlePublishableKey: import_zod3.z.string().regex(THROTTLE_PK_RE).nullable().default(null)
760
764
  }).strict();
761
- var localesSchema = import_zod2.z.object({
765
+ var localesSchema = import_zod3.z.object({
762
766
  default: localeTagSchema.default("en"),
763
- list: import_zod2.z.array(localeTagSchema).min(1).max(50).default(["en"])
767
+ list: import_zod3.z.array(localeTagSchema).min(1).max(50).default(["en"])
764
768
  }).strict().superRefine((locales, ctx) => {
765
769
  if (!locales.list.includes(locales.default)) {
766
770
  customIssue(ctx, "INVALID_VALUE", "The default locale must be in the list", ["list"]);
@@ -770,8 +774,8 @@ var localesSchema = import_zod2.z.object({
770
774
  }
771
775
  });
772
776
  var SITE_SETTINGS_SCHEMA_VERSION = 1;
773
- var siteSettingsSchema = import_zod2.z.object({
774
- schemaVersion: import_zod2.z.literal(1).default(1),
777
+ var siteSettingsSchema = import_zod3.z.object({
778
+ schemaVersion: import_zod3.z.literal(1).default(1),
775
779
  brand: brandSchema.prefault({}),
776
780
  theme: themeSchema.prefault({}),
777
781
  menus: menusSchema.prefault({}),
@@ -782,7 +786,7 @@ var siteSettingsSchema = import_zod2.z.object({
782
786
  connections: connectionsSchema.prefault({}),
783
787
  locales: localesSchema.prefault({}),
784
788
  /** The store origin, for editor links and the default notice endpoint. */
785
- storeUrl: import_zod2.z.string().max(2e3).regex(/^https?:\/\/[^\s/\\]+$/i).nullable().default(null)
789
+ storeUrl: import_zod3.z.string().max(2e3).regex(/^https?:\/\/[^\s/\\]+$/i).nullable().default(null)
786
790
  }).strict();
787
791
  function defaultSiteSettings() {
788
792
  return siteSettingsSchema.parse({});
@@ -817,7 +821,7 @@ function isSettingValue(value, depth = 0) {
817
821
  return false;
818
822
  }
819
823
  }
820
- var settingValueSchema = import_zod3.z.preprocess((input, ctx) => {
824
+ var settingValueSchema = import_zod4.z.preprocess((input, ctx) => {
821
825
  if (!isSettingValue(input)) {
822
826
  ctx.addIssue({
823
827
  code: "custom",
@@ -827,24 +831,24 @@ var settingValueSchema = import_zod3.z.preprocess((input, ctx) => {
827
831
  return null;
828
832
  }
829
833
  return input;
830
- }, import_zod3.z.json());
831
- var nodeIdSchema = import_zod3.z.string().regex(NODE_ID_RE);
834
+ }, import_zod4.z.json());
835
+ var nodeIdSchema = import_zod4.z.string().regex(NODE_ID_RE);
832
836
  var COLOR_VALUE_RE = /^(?:token:[a-z][a-z0-9-]{0,30}|#[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?)$/;
833
- var colorValueSchema = import_zod3.z.string().regex(COLOR_VALUE_RE);
837
+ var colorValueSchema = import_zod4.z.string().regex(COLOR_VALUE_RE);
834
838
  var SPACING_TOKENS = ["none", "xs", "s", "m", "l", "xl", "2xl"];
835
- var spacingValueSchema = import_zod3.z.union([
836
- import_zod3.z.enum(SPACING_TOKENS),
837
- import_zod3.z.number().min(0).max(400)
839
+ var spacingValueSchema = import_zod4.z.union([
840
+ import_zod4.z.enum(SPACING_TOKENS),
841
+ import_zod4.z.number().min(0).max(400)
838
842
  ]);
839
843
  var COMMON_SETTING_KEYS = ["hidden", "anchor", "spacingTop", "spacingBottom"];
840
844
  var ANCHOR_RE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
841
- var anchorSchema = import_zod3.z.string().regex(ANCHOR_RE);
845
+ var anchorSchema = import_zod4.z.string().regex(ANCHOR_RE);
842
846
  var VERTICAL_ALIGN = ["top", "center", "bottom", "stretch"];
843
- var backgroundSchema = import_zod3.z.object({
847
+ var backgroundSchema = import_zod4.z.object({
844
848
  color: colorValueSchema.optional(),
845
849
  image: assetIdSchema.optional(),
846
850
  overlay: colorValueSchema.optional(),
847
- position: import_zod3.z.enum([
851
+ position: import_zod4.z.enum([
848
852
  "center",
849
853
  "top",
850
854
  "bottom",
@@ -855,33 +859,33 @@ var backgroundSchema = import_zod3.z.object({
855
859
  "bottom left",
856
860
  "bottom right"
857
861
  ]).optional(),
858
- size: import_zod3.z.enum(["cover", "contain", "auto"]).optional()
862
+ size: import_zod4.z.enum(["cover", "contain", "auto"]).optional()
859
863
  }).strict();
860
- var sectionPropsSchema = import_zod3.z.object({
861
- width: import_zod3.z.enum(["boxed", "full"]),
862
- contentWidth: import_zod3.z.number().int().min(600).max(1600),
864
+ var sectionPropsSchema = import_zod4.z.object({
865
+ width: import_zod4.z.enum(["boxed", "full"]),
866
+ contentWidth: import_zod4.z.number().int().min(600).max(1600),
863
867
  gap: spacingValueSchema,
864
868
  paddingY: spacingValueSchema,
865
869
  paddingX: spacingValueSchema,
866
- minHeight: import_zod3.z.number().min(0).max(2e3),
867
- verticalAlign: import_zod3.z.enum(VERTICAL_ALIGN),
870
+ minHeight: import_zod4.z.number().min(0).max(2e3),
871
+ verticalAlign: import_zod4.z.enum(VERTICAL_ALIGN),
868
872
  background: backgroundSchema,
869
- stackOrder: import_zod3.z.enum(["normal", "reverse"]),
870
- hidden: import_zod3.z.boolean(),
873
+ stackOrder: import_zod4.z.enum(["normal", "reverse"]),
874
+ hidden: import_zod4.z.boolean(),
871
875
  anchor: anchorSchema
872
876
  }).partial().strict();
873
- var columnWidth = import_zod3.z.number().min(10).max(100).refine((w) => Math.abs(w * 100 - Math.round(w * 100)) < 1e-6, {
877
+ var columnWidth = import_zod4.z.number().min(10).max(100).refine((w) => Math.abs(w * 100 - Math.round(w * 100)) < 1e-6, {
874
878
  message: "A column width has at most 2 decimals"
875
879
  });
876
880
  var columnPropsShape = {
877
881
  width: columnWidth,
878
- verticalAlign: import_zod3.z.enum(VERTICAL_ALIGN),
882
+ verticalAlign: import_zod4.z.enum(VERTICAL_ALIGN),
879
883
  padding: spacingValueSchema,
880
884
  background: backgroundSchema,
881
- hidden: import_zod3.z.boolean(),
885
+ hidden: import_zod4.z.boolean(),
882
886
  anchor: anchorSchema
883
887
  };
884
- var columnPropsSchema = import_zod3.z.object({ ...columnPropsShape, width: columnPropsShape.width }).partial({ verticalAlign: true, padding: true, background: true, hidden: true, anchor: true }).strict();
888
+ var columnPropsSchema = import_zod4.z.object({ ...columnPropsShape, width: columnPropsShape.width }).partial({ verticalAlign: true, padding: true, background: true, hidden: true, anchor: true }).strict();
885
889
  function overridesOf(shape) {
886
890
  const entries = Object.entries(shape).map(
887
891
  ([key, schema]) => [key, schema.nullable().optional()]
@@ -889,13 +893,13 @@ function overridesOf(shape) {
889
893
  return Object.fromEntries(entries);
890
894
  }
891
895
  function responsiveOf(shape) {
892
- const device = import_zod3.z.object(overridesOf(shape)).strict();
893
- return import_zod3.z.object({ tablet: device.optional(), phone: device.optional() }).strict();
896
+ const device = import_zod4.z.object(overridesOf(shape)).strict();
897
+ return import_zod4.z.object({ tablet: device.optional(), phone: device.optional() }).strict();
894
898
  }
895
899
  var sectionResponsive = responsiveOf(sectionPropsSchema.shape);
896
900
  var columnResponsive = responsiveOf(columnPropsShape);
897
901
  var WIDGET_TYPE_RE = /^(?:basic|catalog|commerce|custom)\.[a-z][a-z0-9-]{0,63}$/;
898
- var widgetTypeSchema = import_zod3.z.string().superRefine((value, ctx) => {
902
+ var widgetTypeSchema = import_zod4.z.string().superRefine((value, ctx) => {
899
903
  if (value === "inner-section") {
900
904
  customIssue(
901
905
  ctx,
@@ -910,32 +914,32 @@ var widgetTypeSchema = import_zod3.z.string().superRefine((value, ctx) => {
910
914
  );
911
915
  }
912
916
  });
913
- var dataNameSchema = import_zod3.z.string().regex(/^[a-z][A-Za-z0-9_]{0,39}$/);
914
- var dataBindingSchema = import_zod3.z.union([
915
- import_zod3.z.object({ source: import_zod3.z.string().regex(/^context\.[a-z][a-z0-9-]{0,39}$/) }).strict(),
916
- import_zod3.z.object({
917
- source: import_zod3.z.string().regex(/^(?!context\.)[a-z][a-z0-9]*\.[a-z][a-z0-9-]{0,39}$/),
917
+ var dataNameSchema = import_zod4.z.string().regex(/^[a-z][A-Za-z0-9_]{0,39}$/);
918
+ var dataBindingSchema = import_zod4.z.union([
919
+ import_zod4.z.object({ source: import_zod4.z.string().regex(/^context\.[a-z][a-z0-9-]{0,39}$/) }).strict(),
920
+ import_zod4.z.object({
921
+ source: import_zod4.z.string().regex(/^(?!context\.)[a-z][a-z0-9]*\.[a-z][a-z0-9-]{0,39}$/),
918
922
  params: safeRecord(settingValueSchema)
919
923
  }).strict()
920
924
  ]);
921
925
  var settingsRecord = safeRecord(settingValueSchema);
922
- var widgetNodeSchema = import_zod3.z.object({
926
+ var widgetNodeSchema = import_zod4.z.object({
923
927
  id: nodeIdSchema,
924
928
  type: widgetTypeSchema,
925
- v: import_zod3.z.number().int().min(1).max(9999),
929
+ v: import_zod4.z.number().int().min(1).max(9999),
926
930
  props: settingsRecord,
927
- responsive: import_zod3.z.object({
931
+ responsive: import_zod4.z.object({
928
932
  tablet: safeRecord(settingValueSchema).optional(),
929
933
  phone: safeRecord(settingValueSchema).optional()
930
934
  }).strict().optional(),
931
935
  data: safeRecord(dataBindingSchema, dataNameSchema).optional()
932
936
  }).strict();
933
- var innerColumnNodeSchema = import_zod3.z.object({
937
+ var innerColumnNodeSchema = import_zod4.z.object({
934
938
  id: nodeIdSchema,
935
- type: import_zod3.z.literal("column"),
939
+ type: import_zod4.z.literal("column"),
936
940
  props: columnPropsSchema,
937
941
  responsive: columnResponsive.optional(),
938
- children: import_zod3.z.array(widgetNodeSchema).max(LIMITS.childrenPerColumn)
942
+ children: import_zod4.z.array(widgetNodeSchema).max(LIMITS.childrenPerColumn)
939
943
  }).strict();
940
944
  function checkColumnWidths(columns, ctx) {
941
945
  const sum = columns.reduce((total, column) => total + column.props.width, 0);
@@ -963,57 +967,57 @@ function checkColumnWidths(columns, ctx) {
963
967
  }
964
968
  }
965
969
  var columnsLength = { min: LIMITS.columnsMin, max: LIMITS.columnsMax };
966
- var innerSectionNodeSchema = import_zod3.z.object({
970
+ var innerSectionNodeSchema = import_zod4.z.object({
967
971
  id: nodeIdSchema,
968
- type: import_zod3.z.literal("inner-section"),
972
+ type: import_zod4.z.literal("inner-section"),
969
973
  props: sectionPropsSchema,
970
974
  responsive: sectionResponsive.optional(),
971
- columns: import_zod3.z.array(innerColumnNodeSchema).min(columnsLength.min).max(columnsLength.max)
975
+ columns: import_zod4.z.array(innerColumnNodeSchema).min(columnsLength.min).max(columnsLength.max)
972
976
  }).strict().superRefine((section, ctx) => checkColumnWidths(section.columns, ctx));
973
- var columnNodeSchema = import_zod3.z.object({
977
+ var columnNodeSchema = import_zod4.z.object({
974
978
  id: nodeIdSchema,
975
- type: import_zod3.z.literal("column"),
979
+ type: import_zod4.z.literal("column"),
976
980
  props: columnPropsSchema,
977
981
  responsive: columnResponsive.optional(),
978
- children: import_zod3.z.array(import_zod3.z.union([innerSectionNodeSchema, widgetNodeSchema])).max(LIMITS.childrenPerColumn)
982
+ children: import_zod4.z.array(import_zod4.z.union([innerSectionNodeSchema, widgetNodeSchema])).max(LIMITS.childrenPerColumn)
979
983
  }).strict();
980
- var sectionNodeSchema = import_zod3.z.object({
984
+ var sectionNodeSchema = import_zod4.z.object({
981
985
  id: nodeIdSchema,
982
- type: import_zod3.z.literal("section"),
986
+ type: import_zod4.z.literal("section"),
983
987
  props: sectionPropsSchema,
984
988
  responsive: sectionResponsive.optional(),
985
- columns: import_zod3.z.array(columnNodeSchema).min(columnsLength.min).max(columnsLength.max)
989
+ columns: import_zod4.z.array(columnNodeSchema).min(columnsLength.min).max(columnsLength.max)
986
990
  }).strict().superRefine((section, ctx) => checkColumnWidths(section.columns, ctx));
987
- var assetUrl = import_zod3.z.string().max(2e3).regex(SAFE_HREF);
988
- var frozenAssetSchema = import_zod3.z.object({
991
+ var assetUrl = import_zod4.z.string().max(2e3).regex(SAFE_HREF);
992
+ var frozenAssetSchema = import_zod4.z.object({
989
993
  url: assetUrl,
990
- width: import_zod3.z.number().int().min(1).max(2e4),
991
- height: import_zod3.z.number().int().min(1).max(2e4),
992
- variants: import_zod3.z.array(
993
- import_zod3.z.object({ width: import_zod3.z.number().int().min(1).max(2e4), url: assetUrl }).strict()
994
+ width: import_zod4.z.number().int().min(1).max(2e4),
995
+ height: import_zod4.z.number().int().min(1).max(2e4),
996
+ variants: import_zod4.z.array(
997
+ import_zod4.z.object({ width: import_zod4.z.number().int().min(1).max(2e4), url: assetUrl }).strict()
994
998
  ).max(12)
995
999
  }).strict();
996
1000
  var CUSTOM_SNAPSHOT_KEY_RE = /^custom\.[a-z][a-z0-9-]{0,63}@[1-9][0-9]{0,3}$/;
997
- var customWidgetSnapshotSchema = import_zod3.z.object({
998
- kind: import_zod3.z.enum(["composite", "template"]),
999
- type: import_zod3.z.string().regex(/^custom\.[a-z][a-z0-9-]{0,63}$/),
1000
- v: import_zod3.z.number().int().min(1).max(9999),
1001
- title: import_zod3.z.string().max(100),
1002
- description: import_zod3.z.string().max(500),
1003
- icon: import_zod3.z.string().max(40),
1004
- group: import_zod3.z.literal("custom"),
1005
- settings: import_zod3.z.array(import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())).max(LIMITS.widgetSettings + COMMON_SETTING_KEYS.length),
1006
- renamed: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
1007
- removed: import_zod3.z.array(import_zod3.z.string()).optional()
1001
+ var customWidgetSnapshotSchema = import_zod4.z.object({
1002
+ kind: import_zod4.z.enum(["composite", "template"]),
1003
+ type: import_zod4.z.string().regex(/^custom\.[a-z][a-z0-9-]{0,63}$/),
1004
+ v: import_zod4.z.number().int().min(1).max(9999),
1005
+ title: import_zod4.z.string().max(100),
1006
+ description: import_zod4.z.string().max(500),
1007
+ icon: import_zod4.z.string().max(40),
1008
+ group: import_zod4.z.literal("custom"),
1009
+ settings: import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown())).max(LIMITS.widgetSettings + COMMON_SETTING_KEYS.length),
1010
+ renamed: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional(),
1011
+ removed: import_zod4.z.array(import_zod4.z.string()).optional()
1008
1012
  }).loose();
1009
1013
  var CURRENT_SCHEMA_VERSION = 1;
1010
- var pageDocumentSchema = import_zod3.z.object({
1011
- schemaVersion: import_zod3.z.literal(1),
1012
- sections: import_zod3.z.array(sectionNodeSchema).max(LIMITS.sections),
1014
+ var pageDocumentSchema = import_zod4.z.object({
1015
+ schemaVersion: import_zod4.z.literal(1),
1016
+ sections: import_zod4.z.array(sectionNodeSchema).max(LIMITS.sections),
1013
1017
  // Published snapshots only.
1014
1018
  customWidgets: safeRecord(
1015
1019
  customWidgetSnapshotSchema,
1016
- import_zod3.z.string().regex(CUSTOM_SNAPSHOT_KEY_RE)
1020
+ import_zod4.z.string().regex(CUSTOM_SNAPSHOT_KEY_RE)
1017
1021
  ).optional(),
1018
1022
  assets: safeRecord(frozenAssetSchema, assetIdSchema).optional()
1019
1023
  }).strict().superRefine((doc, ctx) => {
@@ -1146,7 +1150,7 @@ function validateDocument(input) {
1146
1150
  }
1147
1151
 
1148
1152
  // src/widgets.ts
1149
- var import_zod4 = require("zod");
1153
+ var import_zod5 = require("zod");
1150
1154
 
1151
1155
  // src/basics.ts
1152
1156
  var opts = (...values) => values.map((value) => ({ value, label: value.charAt(0).toUpperCase() + value.slice(1) }));
@@ -1513,18 +1517,18 @@ var DATA_RESULT_TYPES = [
1513
1517
  var settingValue = settingValueSchema;
1514
1518
  var CSS_CONTROLS = ["color", "spacing", "font-size", "alignment", "number", "toggle", "select"];
1515
1519
  var CSS_OPTION_RE = /^[a-z0-9][a-z0-9:-]{0,39}$/;
1516
- var settingFieldSchema = import_zod4.z.object({
1517
- key: import_zod4.z.string().regex(/^[a-z][A-Za-z0-9]{0,39}$/),
1518
- label: import_zod4.z.string().min(1).max(100),
1519
- tab: import_zod4.z.enum(SETTING_TABS),
1520
- output: import_zod4.z.enum(["css", "markup"]),
1521
- control: import_zod4.z.enum(SETTING_CONTROLS),
1522
- translatable: import_zod4.z.boolean().optional(),
1520
+ var settingFieldSchema = import_zod5.z.object({
1521
+ key: import_zod5.z.string().regex(/^[a-z][A-Za-z0-9]{0,39}$/),
1522
+ label: import_zod5.z.string().min(1).max(100),
1523
+ tab: import_zod5.z.enum(SETTING_TABS),
1524
+ output: import_zod5.z.enum(["css", "markup"]),
1525
+ control: import_zod5.z.enum(SETTING_CONTROLS),
1526
+ translatable: import_zod5.z.boolean().optional(),
1523
1527
  default: settingValue,
1524
- min: import_zod4.z.number().optional(),
1525
- max: import_zod4.z.number().optional(),
1526
- options: import_zod4.z.array(import_zod4.z.object({ value: import_zod4.z.string().max(60), label: import_zod4.z.string().max(100) }).strict()).max(50).optional(),
1527
- maxLength: import_zod4.z.number().int().min(1).max(2e4).optional()
1528
+ min: import_zod5.z.number().optional(),
1529
+ max: import_zod5.z.number().optional(),
1530
+ options: import_zod5.z.array(import_zod5.z.object({ value: import_zod5.z.string().max(60), label: import_zod5.z.string().max(100) }).strict()).max(50).optional(),
1531
+ maxLength: import_zod5.z.number().int().min(1).max(2e4).optional()
1528
1532
  }).strict().superRefine((field2, ctx) => {
1529
1533
  if (field2.output !== "css") return;
1530
1534
  if (!CSS_CONTROLS.includes(field2.control) || field2.translatable === true) {
@@ -1544,46 +1548,46 @@ var settingFieldSchema = import_zod4.z.object({
1544
1548
  const problem = validateSettingValue(field2, field2.default);
1545
1549
  if (problem !== null) customIssue(ctx, "INVALID_VALUE", `The default is invalid: ${problem}`, ["default"]);
1546
1550
  });
1547
- var fieldSpecSchema = import_zod4.z.object({
1551
+ var fieldSpecSchema = import_zod5.z.object({
1548
1552
  /** A dotted path a template may read, such as `price.display`. */
1549
- name: import_zod4.z.string().regex(/^[a-z][A-Za-z0-9]*(?:\.[a-z][A-Za-z0-9]*)*$/),
1550
- type: import_zod4.z.enum(["string", "number", "boolean", "money", "image", "url", "date", "list"]),
1553
+ name: import_zod5.z.string().regex(/^[a-z][A-Za-z0-9]*(?:\.[a-z][A-Za-z0-9]*)*$/),
1554
+ type: import_zod5.z.enum(["string", "number", "boolean", "money", "image", "url", "date", "list"]),
1551
1555
  example: settingValue.optional()
1552
1556
  }).strict();
1553
- var dataSourceDescriptorSchema = import_zod4.z.object({
1554
- id: import_zod4.z.string().regex(/^[a-z][a-z0-9]*\.[a-z][a-z0-9-]*$/),
1555
- provider: import_zod4.z.enum(["catalog", "commerce"]),
1556
- title: import_zod4.z.string().min(1).max(100),
1557
- description: import_zod4.z.string().max(500),
1558
- params: import_zod4.z.array(settingFieldSchema).max(LIMITS.widgetSettings),
1559
- result: import_zod4.z.enum(DATA_RESULT_TYPES),
1560
- fields: import_zod4.z.array(fieldSpecSchema).max(200),
1561
- perShopper: import_zod4.z.boolean(),
1562
- cacheKind: import_zod4.z.enum(["listings", "product", "reviews", "none"])
1557
+ var dataSourceDescriptorSchema = import_zod5.z.object({
1558
+ id: import_zod5.z.string().regex(/^[a-z][a-z0-9]*\.[a-z][a-z0-9-]*$/),
1559
+ provider: import_zod5.z.enum(["catalog", "commerce"]),
1560
+ title: import_zod5.z.string().min(1).max(100),
1561
+ description: import_zod5.z.string().max(500),
1562
+ params: import_zod5.z.array(settingFieldSchema).max(LIMITS.widgetSettings),
1563
+ result: import_zod5.z.enum(DATA_RESULT_TYPES),
1564
+ fields: import_zod5.z.array(fieldSpecSchema).max(200),
1565
+ perShopper: import_zod5.z.boolean(),
1566
+ cacheKind: import_zod5.z.enum(["listings", "product", "reviews", "none"])
1563
1567
  }).strict();
1564
- var widgetDefinitionSchema = import_zod4.z.object({
1565
- type: import_zod4.z.string().regex(WIDGET_TYPE_RE),
1566
- v: import_zod4.z.number().int().min(1).max(9999),
1567
- title: import_zod4.z.string().min(1).max(100),
1568
- group: import_zod4.z.enum(WIDGET_GROUPS),
1569
- icon: import_zod4.z.string().min(1).max(40),
1570
- description: import_zod4.z.string().min(1).max(500),
1568
+ var widgetDefinitionSchema = import_zod5.z.object({
1569
+ type: import_zod5.z.string().regex(WIDGET_TYPE_RE),
1570
+ v: import_zod5.z.number().int().min(1).max(9999),
1571
+ title: import_zod5.z.string().min(1).max(100),
1572
+ group: import_zod5.z.enum(WIDGET_GROUPS),
1573
+ icon: import_zod5.z.string().min(1).max(40),
1574
+ description: import_zod5.z.string().min(1).max(500),
1571
1575
  // The common props (hidden, anchor, spacing) do not count against the cap.
1572
- settings: import_zod4.z.array(settingFieldSchema).max(LIMITS.widgetSettings + COMMON_SETTING_KEYS.length),
1573
- data: import_zod4.z.record(
1574
- import_zod4.z.string(),
1575
- import_zod4.z.object({
1576
- accepts: import_zod4.z.array(import_zod4.z.enum(DATA_RESULT_TYPES)).min(1),
1577
- required: import_zod4.z.boolean(),
1576
+ settings: import_zod5.z.array(settingFieldSchema).max(LIMITS.widgetSettings + COMMON_SETTING_KEYS.length),
1577
+ data: import_zod5.z.record(
1578
+ import_zod5.z.string(),
1579
+ import_zod5.z.object({
1580
+ accepts: import_zod5.z.array(import_zod5.z.enum(DATA_RESULT_TYPES)).min(1),
1581
+ required: import_zod5.z.boolean(),
1578
1582
  default: dataBindingSchema.optional(),
1579
- label: import_zod4.z.string().min(1).max(100)
1583
+ label: import_zod5.z.string().min(1).max(100)
1580
1584
  }).strict()
1581
1585
  ).optional(),
1582
- placement: import_zod4.z.object({
1583
- slotsOnly: import_zod4.z.boolean().optional(),
1584
- notIn: import_zod4.z.array(import_zod4.z.enum(["header", "footer", "slot"])).optional(),
1586
+ placement: import_zod5.z.object({
1587
+ slotsOnly: import_zod5.z.boolean().optional(),
1588
+ notIn: import_zod5.z.array(import_zod5.z.enum(["header", "footer", "slot"])).optional(),
1585
1589
  /** Not allowed inside an inner section. */
1586
- topLevelOnly: import_zod4.z.boolean().optional()
1590
+ topLevelOnly: import_zod5.z.boolean().optional()
1587
1591
  }).strict().optional()
1588
1592
  }).strict().superRefine((def, ctx) => {
1589
1593
  const own = def.settings.filter(
@@ -1666,7 +1670,7 @@ function validateWidgetProps(def, props) {
1666
1670
  }
1667
1671
  return problems;
1668
1672
  }
1669
- var snapshotPlacementSchema = import_zod4.z.object({ topLevelOnly: import_zod4.z.boolean().optional() }).strict();
1673
+ var snapshotPlacementSchema = import_zod5.z.object({ topLevelOnly: import_zod5.z.boolean().optional() }).strict();
1670
1674
  function snapshotPlacement(snapshot) {
1671
1675
  const raw2 = snapshot.placement;
1672
1676
  if (raw2 === void 0) return void 0;
@@ -2627,55 +2631,55 @@ function invertOps(before, ops, ctx) {
2627
2631
  }
2628
2632
 
2629
2633
  // src/op-schema.ts
2630
- var import_zod5 = require("zod");
2631
- var parentIdSchema = import_zod5.z.union([import_zod5.z.literal("root"), nodeIdSchema]);
2632
- var deviceSchema = import_zod5.z.enum(["tablet", "phone"]);
2634
+ var import_zod6 = require("zod");
2635
+ var parentIdSchema = import_zod6.z.union([import_zod6.z.literal("root"), nodeIdSchema]);
2636
+ var deviceSchema = import_zod6.z.enum(["tablet", "phone"]);
2633
2637
  var propsSchema = safeRecord(settingValueSchema);
2634
- var dataNameSchema2 = import_zod5.z.string().regex(/^[a-z][A-Za-z0-9_]{0,39}$/);
2638
+ var dataNameSchema2 = import_zod6.z.string().regex(/^[a-z][A-Za-z0-9_]{0,39}$/);
2635
2639
  var INDEX_MAX = 1e4;
2636
- var overridesSchema = import_zod5.z.object({ tablet: propsSchema.optional(), phone: propsSchema.optional() }).strict();
2637
- var insertOp = import_zod5.z.object({
2638
- op: import_zod5.z.literal("insert"),
2640
+ var overridesSchema = import_zod6.z.object({ tablet: propsSchema.optional(), phone: propsSchema.optional() }).strict();
2641
+ var insertOp = import_zod6.z.object({
2642
+ op: import_zod6.z.literal("insert"),
2639
2643
  parentId: parentIdSchema,
2640
- index: import_zod5.z.number().int().min(0).max(INDEX_MAX),
2641
- node: import_zod5.z.union([sectionNodeSchema, innerSectionNodeSchema, widgetNodeSchema])
2644
+ index: import_zod6.z.number().int().min(0).max(INDEX_MAX),
2645
+ node: import_zod6.z.union([sectionNodeSchema, innerSectionNodeSchema, widgetNodeSchema])
2642
2646
  }).strict();
2643
- var removeOp = import_zod5.z.object({ op: import_zod5.z.literal("remove"), id: nodeIdSchema }).strict();
2644
- var moveOp = import_zod5.z.object({
2645
- op: import_zod5.z.literal("move"),
2647
+ var removeOp = import_zod6.z.object({ op: import_zod6.z.literal("remove"), id: nodeIdSchema }).strict();
2648
+ var moveOp = import_zod6.z.object({
2649
+ op: import_zod6.z.literal("move"),
2646
2650
  id: nodeIdSchema,
2647
2651
  parentId: parentIdSchema,
2648
- index: import_zod5.z.number().int().min(0).max(INDEX_MAX)
2652
+ index: import_zod6.z.number().int().min(0).max(INDEX_MAX)
2649
2653
  }).strict();
2650
- var setPropsOp = import_zod5.z.object({ op: import_zod5.z.literal("setProps"), id: nodeIdSchema, props: propsSchema }).strict();
2651
- var setResponsiveOp = import_zod5.z.object({
2652
- op: import_zod5.z.literal("setResponsive"),
2654
+ var setPropsOp = import_zod6.z.object({ op: import_zod6.z.literal("setProps"), id: nodeIdSchema, props: propsSchema }).strict();
2655
+ var setResponsiveOp = import_zod6.z.object({
2656
+ op: import_zod6.z.literal("setResponsive"),
2653
2657
  id: nodeIdSchema,
2654
2658
  device: deviceSchema,
2655
2659
  props: propsSchema
2656
2660
  }).strict();
2657
- var setColumnsOp = import_zod5.z.object({
2658
- op: import_zod5.z.literal("setColumns"),
2661
+ var setColumnsOp = import_zod6.z.object({
2662
+ op: import_zod6.z.literal("setColumns"),
2659
2663
  sectionId: nodeIdSchema,
2660
- widths: import_zod5.z.array(import_zod5.z.number().finite()).max(50),
2664
+ widths: import_zod6.z.array(import_zod6.z.number().finite()).max(50),
2661
2665
  device: deviceSchema.optional(),
2662
- moveChildrenTo: import_zod5.z.literal("previous").optional(),
2663
- newIds: import_zod5.z.array(nodeIdSchema).max(50).optional()
2666
+ moveChildrenTo: import_zod6.z.literal("previous").optional(),
2667
+ newIds: import_zod6.z.array(nodeIdSchema).max(50).optional()
2664
2668
  }).strict();
2665
- var setDataOp = import_zod5.z.object({
2666
- op: import_zod5.z.literal("setData"),
2669
+ var setDataOp = import_zod6.z.object({
2670
+ op: import_zod6.z.literal("setData"),
2667
2671
  id: nodeIdSchema,
2668
2672
  name: dataNameSchema2,
2669
2673
  binding: dataBindingSchema.nullable()
2670
2674
  }).strict();
2671
- var replaceDocumentOp = import_zod5.z.object({ op: import_zod5.z.literal("replaceDocument"), document: pageDocumentSchema }).strict();
2672
- var upgradeNodeShape = { op: import_zod5.z.literal("upgradeNode"), id: nodeIdSchema, toV: import_zod5.z.number().int().min(1).max(9999) };
2673
- var upgradeNodeOp = import_zod5.z.object({
2675
+ var replaceDocumentOp = import_zod6.z.object({ op: import_zod6.z.literal("replaceDocument"), document: pageDocumentSchema }).strict();
2676
+ var upgradeNodeShape = { op: import_zod6.z.literal("upgradeNode"), id: nodeIdSchema, toV: import_zod6.z.number().int().min(1).max(9999) };
2677
+ var upgradeNodeOp = import_zod6.z.object({
2674
2678
  ...upgradeNodeShape,
2675
- restore: import_zod5.z.object({ props: propsSchema, responsive: overridesSchema.optional() }).strict().optional()
2679
+ restore: import_zod6.z.object({ props: propsSchema, responsive: overridesSchema.optional() }).strict().optional()
2676
2680
  }).strict();
2677
- var agentUpgradeNodeOp = import_zod5.z.object(upgradeNodeShape).strict();
2678
- var docOpSchema = import_zod5.z.discriminatedUnion("op", [
2681
+ var agentUpgradeNodeOp = import_zod6.z.object(upgradeNodeShape).strict();
2682
+ var docOpSchema = import_zod6.z.discriminatedUnion("op", [
2679
2683
  insertOp,
2680
2684
  removeOp,
2681
2685
  moveOp,
@@ -2687,7 +2691,7 @@ var docOpSchema = import_zod5.z.discriminatedUnion("op", [
2687
2691
  upgradeNodeOp
2688
2692
  ]);
2689
2693
  var AGENT_MAX_OPS = 500;
2690
- var agentDocOpSchema = import_zod5.z.discriminatedUnion("op", [
2694
+ var agentDocOpSchema = import_zod6.z.discriminatedUnion("op", [
2691
2695
  insertOp,
2692
2696
  removeOp,
2693
2697
  moveOp,
@@ -2697,7 +2701,7 @@ var agentDocOpSchema = import_zod5.z.discriminatedUnion("op", [
2697
2701
  setDataOp,
2698
2702
  agentUpgradeNodeOp
2699
2703
  ]);
2700
- var agentDocOpsSchema = import_zod5.z.array(agentDocOpSchema).min(1).max(AGENT_MAX_OPS);
2704
+ var agentDocOpsSchema = import_zod6.z.array(agentDocOpSchema).min(1).max(AGENT_MAX_OPS);
2701
2705
 
2702
2706
  // src/urls.ts
2703
2707
  var MAX_URL_LENGTH = 2e3;
@@ -4464,26 +4468,26 @@ function sanitizeWidgetCss(css, type) {
4464
4468
  }
4465
4469
 
4466
4470
  // src/custom-widget.ts
4467
- var import_zod6 = require("zod");
4471
+ var import_zod7 = require("zod");
4468
4472
  var SETTING_KEY_RE = /^[a-z][A-Za-z0-9]{0,39}$/;
4469
- var settingKey = import_zod6.z.string().regex(SETTING_KEY_RE);
4470
- var inputName = import_zod6.z.string().regex(/^[a-z][A-Za-z0-9]{0,39}$/);
4473
+ var settingKey = import_zod7.z.string().regex(SETTING_KEY_RE);
4474
+ var inputName = import_zod7.z.string().regex(/^[a-z][A-Za-z0-9]{0,39}$/);
4471
4475
  var dataInputShape = {
4472
- accepts: import_zod6.z.array(import_zod6.z.enum(DATA_RESULT_TYPES)).min(1).max(DATA_RESULT_TYPES.length),
4473
- required: import_zod6.z.boolean(),
4474
- label: import_zod6.z.string().min(1).max(100)
4476
+ accepts: import_zod7.z.array(import_zod7.z.enum(DATA_RESULT_TYPES)).min(1).max(DATA_RESULT_TYPES.length),
4477
+ required: import_zod7.z.boolean(),
4478
+ label: import_zod7.z.string().min(1).max(100)
4475
4479
  };
4476
4480
  var common = {
4477
- type: import_zod6.z.string().regex(/^custom\.[a-z][a-z0-9-]{0,63}$/),
4478
- v: import_zod6.z.number().int().min(1).max(9999),
4479
- title: import_zod6.z.string().min(1).max(100),
4480
- description: import_zod6.z.string().min(1).max(500),
4481
- icon: import_zod6.z.string().min(1).max(40),
4482
- group: import_zod6.z.literal("custom"),
4481
+ type: import_zod7.z.string().regex(/^custom\.[a-z][a-z0-9-]{0,63}$/),
4482
+ v: import_zod7.z.number().int().min(1).max(9999),
4483
+ title: import_zod7.z.string().min(1).max(100),
4484
+ description: import_zod7.z.string().min(1).max(500),
4485
+ icon: import_zod7.z.string().min(1).max(40),
4486
+ group: import_zod7.z.literal("custom"),
4483
4487
  // The common props (hidden, anchor, spacing) are added on normalisation and do not count.
4484
- settings: import_zod6.z.array(settingFieldSchema).max(LIMITS.widgetSettings + COMMON_SETTING_KEYS.length),
4488
+ settings: import_zod7.z.array(settingFieldSchema).max(LIMITS.widgetSettings + COMMON_SETTING_KEYS.length),
4485
4489
  renamed: safeRecord(settingKey, settingKey).optional(),
4486
- removed: import_zod6.z.array(settingKey).max(LIMITS.widgetSettings).optional()
4490
+ removed: import_zod7.z.array(settingKey).max(LIMITS.widgetSettings).optional()
4487
4491
  };
4488
4492
  function limitInputs(data, ctx) {
4489
4493
  if (data !== void 0 && Object.keys(data).length > LIMITS.customWidgetDataInputs) {
@@ -4495,31 +4499,31 @@ function limitInputs(data, ctx) {
4495
4499
  );
4496
4500
  }
4497
4501
  }
4498
- var templateSchema = import_zod6.z.object({
4499
- kind: import_zod6.z.literal("template"),
4502
+ var templateSchema = import_zod7.z.object({
4503
+ kind: import_zod7.z.literal("template"),
4500
4504
  ...common,
4501
- data: safeRecord(import_zod6.z.object(dataInputShape).strict(), inputName).optional(),
4502
- template: import_zod6.z.string(),
4503
- css: import_zod6.z.string().optional()
4505
+ data: safeRecord(import_zod7.z.object(dataInputShape).strict(), inputName).optional(),
4506
+ template: import_zod7.z.string(),
4507
+ css: import_zod7.z.string().optional()
4504
4508
  }).strict().superRefine((def, ctx) => limitInputs(def.data, ctx));
4505
4509
  var targetNode = nodeIdSchema;
4506
- var compositeSchema = import_zod6.z.object({
4507
- kind: import_zod6.z.literal("composite"),
4510
+ var compositeSchema = import_zod7.z.object({
4511
+ kind: import_zod7.z.literal("composite"),
4508
4512
  ...common,
4509
- body: import_zod6.z.object({
4510
- columns: import_zod6.z.array(import_zod6.z.unknown()).optional(),
4511
- stack: import_zod6.z.array(import_zod6.z.unknown()).optional()
4513
+ body: import_zod7.z.object({
4514
+ columns: import_zod7.z.array(import_zod7.z.unknown()).optional(),
4515
+ stack: import_zod7.z.array(import_zod7.z.unknown()).optional()
4512
4516
  }).strict(),
4513
- bindings: import_zod6.z.array(
4514
- import_zod6.z.object({
4517
+ bindings: import_zod7.z.array(
4518
+ import_zod7.z.object({
4515
4519
  setting: settingKey,
4516
- targets: import_zod6.z.array(import_zod6.z.object({ node: targetNode, prop: settingKey }).strict()).min(1).max(20)
4520
+ targets: import_zod7.z.array(import_zod7.z.object({ node: targetNode, prop: settingKey }).strict()).min(1).max(20)
4517
4521
  }).strict()
4518
4522
  ).max(LIMITS.widgetSettings),
4519
4523
  data: safeRecord(
4520
- import_zod6.z.object({
4524
+ import_zod7.z.object({
4521
4525
  ...dataInputShape,
4522
- targets: import_zod6.z.array(import_zod6.z.object({ node: targetNode, input: inputName }).strict()).min(1).max(20)
4526
+ targets: import_zod7.z.array(import_zod7.z.object({ node: targetNode, input: inputName }).strict()).min(1).max(20)
4523
4527
  }).strict(),
4524
4528
  inputName
4525
4529
  ).optional()