@makeswift/prop-controllers 0.2.1 → 0.3.0-canary.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Backgrounds: () => Backgrounds,
+  BackgroundsPropControllerDataV2Type: () => BackgroundsPropControllerDataV2Type,
   Border: () => Border,
   BorderPropControllerFormat: () => BorderPropControllerFormat,
   BorderRadius: () => BorderRadius,
@@ -42,9 +43,11 @@ __export(src_exports, {
   Number: () => Number,
   Padding: () => Padding,
   PaddingPropControllerFormat: () => PaddingPropControllerFormat,
+  PropDef: () => PropDef,
   ResponsiveColor: () => ResponsiveColor,
   ResponsiveLength: () => ResponsiveLength,
   ResponsiveLengthPropControllerDataV1Type: () => ResponsiveLengthPropControllerDataV1Type,
+  ResponsiveNumber: () => ResponsiveNumber,
   Shadows: () => Shadows,
   Table: () => Table,
   TableFormFields: () => TableFormFields,
@@ -54,10 +57,12 @@ __export(src_exports, {
   Video: () => Video,
   Width: () => Width,
   WidthPropControllerFormat: () => WidthPropControllerFormat,
+  backgroundImageDataSchema: () => backgroundImageDataSchema,
   backgroundsPropControllerDataSchema: () => backgroundsPropControllerDataSchema,
   borderPropControllerDataSchema: () => borderPropControllerDataSchema,
   borderRadiusPropControllerDataSchema: () => borderRadiusPropControllerDataSchema,
   checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
+  colorDataSchema: () => colorDataSchema,
   copyBackgroundsPropControllerData: () => copyBackgroundsPropControllerData,
   copyBorderPropControllerData: () => copyBorderPropControllerData,
   copyElementIDPropControllerData: () => copyElementIDPropControllerData,
@@ -77,7 +82,6 @@ __export(src_exports, {
   createDatePropControllerDataFromString: () => createDatePropControllerDataFromString,
   createElementIDPropControllerDataFromElementID: () => createElementIDPropControllerDataFromElementID,
   createFontPropControllerDataFromResponsiveFontData: () => createFontPropControllerDataFromResponsiveFontData,
-  createGapXPropControllerDataFromResponsiveGapData: () => createGapXPropControllerDataFromResponsiveGapData,
   createGapYPropControllerDataFromResponsiveGapData: () => createGapYPropControllerDataFromResponsiveGapData,
   createGridPropControllerDataFromGridData: () => createGridPropControllerDataFromGridData,
   createImagePropControllerDataFromImageData: () => createImagePropControllerDataFromImageData,
@@ -103,7 +107,7 @@ __export(src_exports, {
   elementIDPropControllerDataSchema: () => elementIDPropControllerDataSchema,
   elementSchema: () => elementSchema,
   fontPropControllerDataSchema: () => fontPropControllerDataSchema,
-  gapXPropControllerDataSchema: () => gapXPropControllerDataSchema,
+  gapDataSchema: () => gapDataSchema,
   gapYPropControllerDataSchema: () => gapYPropControllerDataSchema,
   getBackgroundsPropControllerDataResponsiveBackgroundsData: () => getBackgroundsPropControllerDataResponsiveBackgroundsData,
   getBackgroundsPropControllerFileIds: () => getBackgroundsPropControllerFileIds,
@@ -115,7 +119,6 @@ __export(src_exports, {
   getDatePropControllerDataString: () => getDatePropControllerDataString,
   getElementIDPropControllerDataElementID: () => getElementIDPropControllerDataElementID,
   getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
-  getGapXPropControllerDataResponsiveGapData: () => getGapXPropControllerDataResponsiveGapData,
   getGapYPropControllerDataResponsiveGapData: () => getGapYPropControllerDataResponsiveGapData,
   getGridPropControllerDataGridData: () => getGridPropControllerDataGridData,
   getGridPropControllerElementChildren: () => getGridPropControllerElementChildren,
@@ -146,8 +149,13 @@ __export(src_exports, {
   getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
   gridPropControllerDataSchema: () => gridPropControllerDataSchema,
+  imageBackgroundDataSchema: () => imageBackgroundDataSchema,
+  imageDataSchema: () => imageDataSchema,
+  imageDataV0Schema: () => imageDataV0Schema,
+  imageDataV1Schema: () => imageDataV1Schema,
   imagePropControllerDataSchema: () => imagePropControllerDataSchema,
   imagesPropControllerDataSchema: () => imagesPropControllerDataSchema,
+  lengthDataSchema: () => lengthDataSchema,
   linkDataSchema: () => linkDataSchema,
   linkPropControllerDataSchema: () => linkPropControllerDataSchema,
   marginPropControllerDataSchema: () => marginPropControllerDataSchema,
@@ -156,17 +164,23 @@ __export(src_exports, {
   numberPropControllerDataSchema: () => numberPropControllerDataSchema,
   paddingPropControllerDataSchema: () => paddingPropControllerDataSchema,
   responsiveColorPropControllerDataSchema: () => responsiveColorPropControllerDataSchema,
+  responsiveGapDataSchema: () => responsiveGapDataSchema,
   responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
+  responsiveNumberValueSchema: () => responsiveNumberValueSchema,
   shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema,
   tableFormFieldsPropControllerDataSchema: () => tableFormFieldsPropControllerDataSchema,
   tablePropControllerDataSchema: () => tablePropControllerDataSchema,
   textAreaPropControllerDataSchema: () => textAreaPropControllerDataSchema,
   textStylePropControllerDataSchema: () => textStylePropControllerDataSchema,
+  versionedPropDef: () => versionedPropDef,
   videoPropControllerDataSchema: () => videoPropControllerDataSchema,
   widthPropControllerDataSchema: () => widthPropControllerDataSchema
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/data.ts
+var import_zod2 = require("zod");
+
 // src/prop-controllers.ts
 var import_zod = require("zod");
 var Types = {
@@ -190,6 +204,7 @@ var Types = {
   Shadows: "Shadows",
   ResponsiveColor: "ResponsiveColor",
   ResponsiveLength: "ResponsiveLength",
+  ResponsiveNumber: "ResponsiveNumber",
   TextArea: "TextArea",
   Table: "Table",
   TableFormFields: "TableFormFields",
@@ -224,12 +239,7 @@ var elementSchema = import_zod.z.union([
   elementReferenceSchema
 ]);
 
-// src/backgrounds/backgrounds.ts
-var import_zod3 = require("zod");
-var import_ts_pattern = require("ts-pattern");
-
 // src/data.ts
-var import_zod2 = require("zod");
 var colorDataSchema = import_zod2.z.object({
   swatchId: import_zod2.z.string(),
   alpha: import_zod2.z.number()
@@ -262,113 +272,183 @@ var imageDataV1Schema = import_zod2.z.union([
   imageDataV1ExternalFileSchema
 ]);
 var imageDataSchema = import_zod2.z.union([imageDataV0Schema, imageDataV1Schema]);
+var responsiveNumberValueSchema = createResponsiveValueSchema(
+  import_zod2.z.number()
+);
+
+// src/versioned.ts
+var import_ts_pattern = require("ts-pattern");
+var import_zod3 = require("zod");
+var PropDef = class extends Function {
+  __associated_types__;
+  _callable;
+  constructor() {
+    super("...args", "return this._callable.__call__(...args)");
+    this._callable = this.bind(this);
+    return this._callable;
+  }
+};
+var versionedPropDef = () => (type, valueSchema, discriminator) => {
+  const schemaV0 = valueSchema;
+  const schemaV1 = import_zod3.z.object({
+    [ControlDataTypeKey]: import_zod3.z.literal(discriminator.dataKey),
+    value: valueSchema
+  });
+  const schema = import_zod3.z.union([schemaV0, schemaV1]);
+  class Def extends PropDef {
+    schemaV0 = schemaV0;
+    schemaV1 = schemaV1;
+    schema = schema;
+    type = type;
+    discriminator = discriminator;
+    __call__(options) {
+      return {
+        type,
+        version: discriminator.version,
+        options: options ?? {}
+      };
+    }
+    fromPropData(propData) {
+      return (0, import_ts_pattern.match)(propData).with(
+        {
+          [ControlDataTypeKey]: discriminator.dataKey
+        },
+        (v1) => v1.value
+      ).otherwise((v0) => v0);
+    }
+    toPropData(data, descriptor) {
+      return (0, import_ts_pattern.match)(descriptor).with(
+        { version: discriminator.version },
+        () => ({
+          [ControlDataTypeKey]: discriminator.dataKey,
+          value: data
+        })
+      ).otherwise(() => data);
+    }
+  }
+  return new Def();
+};
+
+// src/gap-x/gap-x.ts
+var GapX = versionedPropDef()(Types.GapX, responsiveGapDataSchema, {
+  version: 1,
+  dataKey: "prop-controllers::gap-x::v1"
+});
+
+// src/responsive-number/responsive-number.ts
+var ResponsiveNumber = versionedPropDef()(Types.ResponsiveNumber, responsiveNumberValueSchema, {
+  version: 1,
+  dataKey: "prop-controllers::responsive-number::v1"
+});
 
 // src/backgrounds/backgrounds.ts
-var colorBackgroundDataSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("color"),
-  id: import_zod3.z.string(),
+var import_zod4 = require("zod");
+var import_ts_pattern2 = require("ts-pattern");
+var colorBackgroundDataSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("color"),
+  id: import_zod4.z.string(),
   payload: colorDataSchema.nullable()
 });
-var gradientStopDataSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  location: import_zod3.z.number(),
+var gradientStopDataSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  location: import_zod4.z.number(),
   color: colorDataSchema.nullable()
 });
-var gradientDataSchema = import_zod3.z.object({
-  angle: import_zod3.z.number().optional(),
-  isRadial: import_zod3.z.boolean().optional(),
-  stops: import_zod3.z.array(gradientStopDataSchema)
+var gradientDataSchema = import_zod4.z.object({
+  angle: import_zod4.z.number().optional(),
+  isRadial: import_zod4.z.boolean().optional(),
+  stops: import_zod4.z.array(gradientStopDataSchema)
 });
-var gradientBackgroundDataSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("gradient"),
-  id: import_zod3.z.string(),
+var gradientBackgroundDataSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("gradient"),
+  id: import_zod4.z.string(),
   payload: gradientDataSchema
 });
-var backgroundImagePositionDataSchema = import_zod3.z.object({
-  x: import_zod3.z.number(),
-  y: import_zod3.z.number()
+var backgroundImagePositionDataSchema = import_zod4.z.object({
+  x: import_zod4.z.number(),
+  y: import_zod4.z.number()
 });
-var backgroundSizeDataSchema = import_zod3.z.union([
-  import_zod3.z.literal("cover"),
-  import_zod3.z.literal("contain"),
-  import_zod3.z.literal("auto")
+var backgroundSizeDataSchema = import_zod4.z.union([
+  import_zod4.z.literal("cover"),
+  import_zod4.z.literal("contain"),
+  import_zod4.z.literal("auto")
 ]);
-var backgroundImageRepeatDataSchema = import_zod3.z.union([
-  import_zod3.z.literal("no-repeat"),
-  import_zod3.z.literal("repeat-x"),
-  import_zod3.z.literal("repeat-y"),
-  import_zod3.z.literal("repeat")
+var backgroundImageRepeatDataSchema = import_zod4.z.union([
+  import_zod4.z.literal("no-repeat"),
+  import_zod4.z.literal("repeat-x"),
+  import_zod4.z.literal("repeat-y"),
+  import_zod4.z.literal("repeat")
 ]);
-var backgroundImageV0DataSchema = import_zod3.z.object({
+var backgroundImageV0DataSchema = import_zod4.z.object({
   imageId: imageDataV0Schema,
   position: backgroundImagePositionDataSchema,
   size: backgroundSizeDataSchema.optional(),
   repeat: backgroundImageRepeatDataSchema.optional(),
-  opacity: import_zod3.z.number().optional(),
-  parallax: import_zod3.z.number().optional(),
-  priority: import_zod3.z.boolean().optional()
+  opacity: import_zod4.z.number().optional(),
+  parallax: import_zod4.z.number().optional(),
+  priority: import_zod4.z.boolean().optional()
 });
-var backgroundImageV1DataSchema = import_zod3.z.object({
-  version: import_zod3.z.literal(1),
+var backgroundImageV1DataSchema = import_zod4.z.object({
+  version: import_zod4.z.literal(1),
   image: imageDataV1Schema,
   position: backgroundImagePositionDataSchema,
   size: backgroundSizeDataSchema.optional(),
   repeat: backgroundImageRepeatDataSchema.optional(),
-  opacity: import_zod3.z.number().optional(),
-  parallax: import_zod3.z.number().optional(),
-  priority: import_zod3.z.boolean().optional()
+  opacity: import_zod4.z.number().optional(),
+  parallax: import_zod4.z.number().optional(),
+  priority: import_zod4.z.boolean().optional()
 });
-var backgroundImageDataSchema = import_zod3.z.union([
+var backgroundImageDataSchema = import_zod4.z.union([
   backgroundImageV0DataSchema,
   backgroundImageV1DataSchema
 ]);
-var imageBackgroundV0DataSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("image"),
-  id: import_zod3.z.string(),
+var imageBackgroundV0DataSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("image"),
+  id: import_zod4.z.string(),
   payload: backgroundImageV0DataSchema
 });
-var imageBackgroundV1DataSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("image-v1"),
-  id: import_zod3.z.string(),
+var imageBackgroundV1DataSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("image-v1"),
+  id: import_zod4.z.string(),
   payload: backgroundImageV1DataSchema
 });
-var imageBackgroundDataSchema = import_zod3.z.union([
+var imageBackgroundDataSchema = import_zod4.z.union([
   imageBackgroundV0DataSchema,
   imageBackgroundV1DataSchema
 ]);
-var backgroundVideoAspectRatioDataSchema = import_zod3.z.union([
-  import_zod3.z.literal("wide"),
-  import_zod3.z.literal("standard")
+var backgroundVideoAspectRatioDataSchema = import_zod4.z.union([
+  import_zod4.z.literal("wide"),
+  import_zod4.z.literal("standard")
 ]);
-var backgroundVideoDataSchema = import_zod3.z.object({
-  url: import_zod3.z.string().optional(),
+var backgroundVideoDataSchema = import_zod4.z.object({
+  url: import_zod4.z.string().optional(),
   maskColor: colorDataSchema.nullable().optional(),
-  opacity: import_zod3.z.number().optional(),
-  zoom: import_zod3.z.number().optional(),
+  opacity: import_zod4.z.number().optional(),
+  zoom: import_zod4.z.number().optional(),
   aspectRatio: backgroundVideoAspectRatioDataSchema.optional(),
-  parallax: import_zod3.z.number().optional()
+  parallax: import_zod4.z.number().optional()
 });
-var videoBackgroundDataSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("video"),
-  id: import_zod3.z.string(),
+var videoBackgroundDataSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("video"),
+  id: import_zod4.z.string(),
   payload: backgroundVideoDataSchema
 });
-var backgroundDataSchema = import_zod3.z.union([
+var backgroundDataSchema = import_zod4.z.union([
   colorBackgroundDataSchema,
   gradientBackgroundDataSchema,
   imageBackgroundDataSchema,
   videoBackgroundDataSchema
 ]);
 var responsiveBackgroundsDataSchema = createResponsiveValueSchema(
-  import_zod3.z.array(backgroundDataSchema)
+  import_zod4.z.array(backgroundDataSchema)
 );
 var backgroundsPropControllerDataV1Schema = responsiveBackgroundsDataSchema;
 var BackgroundsPropControllerDataV2Type = "prop-controllers::backgrounds::v2";
-var backgroundsPropControllerDataV2Schema = import_zod3.z.object({
-  [ControlDataTypeKey]: import_zod3.z.literal(BackgroundsPropControllerDataV2Type),
+var backgroundsPropControllerDataV2Schema = import_zod4.z.object({
+  [ControlDataTypeKey]: import_zod4.z.literal(BackgroundsPropControllerDataV2Type),
   value: responsiveBackgroundsDataSchema
 });
-var backgroundsPropControllerDataSchema = import_zod3.z.union([
+var backgroundsPropControllerDataSchema = import_zod4.z.union([
   backgroundsPropControllerDataV1Schema,
   backgroundsPropControllerDataV2Schema
 ]);
@@ -376,13 +456,13 @@ function Backgrounds(options = {}) {
   return { type: Types.Backgrounds, version: 2, options };
 }
 function getBackgroundsPropControllerDataResponsiveBackgroundsData(data) {
-  return (0, import_ts_pattern.match)(data).with(
+  return (0, import_ts_pattern2.match)(data).with(
     { [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type },
     (v2) => v2.value
   ).otherwise((v0) => v0);
 }
 function createBackgroundsPropControllerDataFromResponsiveBackgroundsData(data, definition) {
-  return (0, import_ts_pattern.match)(definition).with(
+  return (0, import_ts_pattern2.match)(definition).with(
     { version: 2 },
     () => ({
       [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type,
@@ -393,13 +473,13 @@ function createBackgroundsPropControllerDataFromResponsiveBackgroundsData(data,
 function getBackgroundsPropControllerFileIds(data) {
   const value = getBackgroundsPropControllerDataResponsiveBackgroundsData(data);
   return value?.flatMap((override) => override.value).flatMap((backgroundItem) => {
-    return (0, import_ts_pattern.match)(backgroundItem).with(
+    return (0, import_ts_pattern2.match)(backgroundItem).with(
       {
         type: "image-v1",
         payload: { image: { type: "makeswift-file" } }
       },
       (item) => [item.payload.image.id]
-    ).with({ type: "image", payload: { imageId: import_ts_pattern.P.string } }, (item) => [
+    ).with({ type: "image", payload: { imageId: import_ts_pattern2.P.string } }, (item) => [
       item.payload.imageId
     ]).otherwise(() => []);
   }) ?? [];
@@ -425,7 +505,7 @@ function copyResponsiveBackgroundsData(descriptor, data, context) {
   return data.map((override) => ({
     ...override,
     value: override.value.map((backgroundItem) => {
-      return (0, import_ts_pattern.match)([descriptor, backgroundItem]).with([import_ts_pattern.P.any, { type: "color" }], ([, item]) => {
+      return (0, import_ts_pattern2.match)([descriptor, backgroundItem]).with([import_ts_pattern2.P.any, { type: "color" }], ([, item]) => {
         return {
           ...item,
           payload: item.payload === null ? null : {
@@ -435,7 +515,7 @@ function copyResponsiveBackgroundsData(descriptor, data, context) {
             ) ?? item.payload.swatchId
           }
         };
-      }).with([import_ts_pattern.P.any, { type: "gradient" }], ([, item]) => {
+      }).with([import_ts_pattern2.P.any, { type: "gradient" }], ([, item]) => {
         return {
           ...item,
           payload: {
@@ -453,7 +533,7 @@ function copyResponsiveBackgroundsData(descriptor, data, context) {
         };
       }).with(
         [
-          { version: import_ts_pattern.P.when((v) => v && v >= 1) },
+          { version: import_ts_pattern2.P.when((v) => v && v >= 1) },
           {
             type: "image-v1",
             payload: {
@@ -477,7 +557,7 @@ function copyResponsiveBackgroundsData(descriptor, data, context) {
           };
         }
       ).with(
-        [import_ts_pattern.P.any, { type: "image", payload: { imageId: import_ts_pattern.P.string } }],
+        [import_ts_pattern2.P.any, { type: "image", payload: { imageId: import_ts_pattern2.P.string } }],
         ([, item]) => {
           return {
             ...item,
@@ -494,7 +574,7 @@ function copyResponsiveBackgroundsData(descriptor, data, context) {
   }));
 }
 function copyBackgroundsPropControllerData(descriptor, data, context) {
-  return (0, import_ts_pattern.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern2.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type },
     (v1) => {
       const value = copyResponsiveBackgroundsData(
@@ -513,17 +593,17 @@ function copyBackgroundsPropControllerData(descriptor, data, context) {
 }
 
 // src/border/border.ts
-var import_ts_pattern2 = require("ts-pattern");
-var import_zod4 = require("zod");
-var borderSideDataSchema = import_zod4.z.object({
-  width: import_zod4.z.number().nullable().optional(),
-  style: import_zod4.z.enum(["dashed", "dotted", "solid"]),
+var import_ts_pattern3 = require("ts-pattern");
+var import_zod5 = require("zod");
+var borderSideDataSchema = import_zod5.z.object({
+  width: import_zod5.z.number().nullable().optional(),
+  style: import_zod5.z.enum(["dashed", "dotted", "solid"]),
   color: colorDataSchema.nullable().optional()
 }).transform((v) => ({
   ...v,
   width: v.width
 }));
-var borderDataSchema = import_zod4.z.object({
+var borderDataSchema = import_zod5.z.object({
   borderTop: borderSideDataSchema.nullable().optional(),
   borderRight: borderSideDataSchema.nullable().optional(),
   borderBottom: borderSideDataSchema.nullable().optional(),
@@ -537,11 +617,11 @@ var borderDataSchema = import_zod4.z.object({
 var responsiveBorderDataSchema = createResponsiveValueSchema(borderDataSchema);
 var borderPropControllerDataV0Schema = responsiveBorderDataSchema;
 var BorderPropControllerDataV1Type = "prop-controllers::border::v1";
-var borderPropControllerDataV1Schema = import_zod4.z.object({
-  [ControlDataTypeKey]: import_zod4.z.literal(BorderPropControllerDataV1Type),
+var borderPropControllerDataV1Schema = import_zod5.z.object({
+  [ControlDataTypeKey]: import_zod5.z.literal(BorderPropControllerDataV1Type),
   value: responsiveBorderDataSchema
 });
-var borderPropControllerDataSchema = import_zod4.z.union([
+var borderPropControllerDataSchema = import_zod5.z.union([
   borderPropControllerDataV0Schema,
   borderPropControllerDataV1Schema
 ]);
@@ -554,13 +634,13 @@ function Border(options = {}) {
 }
 Border.Format = BorderPropControllerFormat;
 function getBorderPropControllerDataResponsiveBorderData(data) {
-  return (0, import_ts_pattern2.match)(data).with(
+  return (0, import_ts_pattern3.match)(data).with(
     { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createBorderPropControllerDataFromResponsiveBorderData(definition, responsiveBorderData) {
-  return (0, import_ts_pattern2.match)(definition).with(
+  return (0, import_ts_pattern3.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: BorderPropControllerDataV1Type,
@@ -612,7 +692,7 @@ function copyResponsiveBorderData(data, context) {
   }
 }
 function copyBorderPropControllerData(data, context) {
-  return (0, import_ts_pattern2.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern3.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: BorderPropControllerDataV1Type,
@@ -622,9 +702,9 @@ function copyBorderPropControllerData(data, context) {
 }
 
 // src/border-radius/border-radius.ts
-var import_zod5 = require("zod");
-var import_ts_pattern3 = require("ts-pattern");
-var borderRadiusDataSchema = import_zod5.z.object({
+var import_zod6 = require("zod");
+var import_ts_pattern4 = require("ts-pattern");
+var borderRadiusDataSchema = import_zod6.z.object({
   borderTopLeftRadius: lengthDataSchema.nullable().optional(),
   borderTopRightRadius: lengthDataSchema.nullable().optional(),
   borderBottomLeftRadius: lengthDataSchema.nullable().optional(),
@@ -635,11 +715,11 @@ var responsiveBorderRadiusDataSchema = createResponsiveValueSchema(
 );
 var borderRadiusPropControllerDataV0Schema = responsiveBorderRadiusDataSchema;
 var BorderRadiusPropControllerDataV1Type = "prop-controllers::border-radius::v1";
-var borderRadiusPropControllerDataV1Schema = import_zod5.z.object({
-  [ControlDataTypeKey]: import_zod5.z.literal(BorderRadiusPropControllerDataV1Type),
+var borderRadiusPropControllerDataV1Schema = import_zod6.z.object({
+  [ControlDataTypeKey]: import_zod6.z.literal(BorderRadiusPropControllerDataV1Type),
   value: responsiveBorderRadiusDataSchema
 });
-var borderRadiusPropControllerDataSchema = import_zod5.z.union([
+var borderRadiusPropControllerDataSchema = import_zod6.z.union([
   borderRadiusPropControllerDataV0Schema,
   borderRadiusPropControllerDataV1Schema
 ]);
@@ -652,13 +732,13 @@ function BorderRadius(options = {}) {
 }
 BorderRadius.Format = BorderRadiusPropControllerFormat;
 function getBorderRadiusPropControllerDataResponsiveBorderRadiusData(data) {
-  return (0, import_ts_pattern3.match)(data).with(
+  return (0, import_ts_pattern4.match)(data).with(
     { [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(definition, responsiveBorderRadiusData) {
-  return (0, import_ts_pattern3.match)(definition).with(
+  return (0, import_ts_pattern4.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type,
@@ -668,15 +748,15 @@ function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(defi
 }
 
 // src/checkbox/checkbox.ts
-var import_zod6 = require("zod");
-var import_ts_pattern4 = require("ts-pattern");
-var checkboxPropControllerDataV0Schema = import_zod6.z.boolean();
+var import_zod7 = require("zod");
+var import_ts_pattern5 = require("ts-pattern");
+var checkboxPropControllerDataV0Schema = import_zod7.z.boolean();
 var CheckboxPropControllerDataV1Type = "prop-controllers::checkbox::v1";
-var checkboxPropControllerDataV1Schema = import_zod6.z.object({
-  [ControlDataTypeKey]: import_zod6.z.literal(CheckboxPropControllerDataV1Type),
-  value: import_zod6.z.boolean()
+var checkboxPropControllerDataV1Schema = import_zod7.z.object({
+  [ControlDataTypeKey]: import_zod7.z.literal(CheckboxPropControllerDataV1Type),
+  value: import_zod7.z.boolean()
 });
-var checkboxPropControllerDataSchema = import_zod6.z.union([
+var checkboxPropControllerDataSchema = import_zod7.z.union([
   checkboxPropControllerDataV0Schema,
   checkboxPropControllerDataV1Schema
 ]);
@@ -684,15 +764,15 @@ function Checkbox(options) {
   return { type: Types.Checkbox, version: 1, options };
 }
 function getCheckboxPropControllerDataBoolean(data) {
-  return (0, import_ts_pattern4.match)(data).with(
+  return (0, import_ts_pattern5.match)(data).with(
     { [ControlDataTypeKey]: CheckboxPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createCheckboxPropControllerDataFromBoolean(value, definition) {
-  return (0, import_ts_pattern4.match)(definition).with(
+  return (0, import_ts_pattern5.match)(definition).with(
     { version: 1 },
-    import_ts_pattern4.P.nullish,
+    import_ts_pattern5.P.nullish,
     () => ({
       [ControlDataTypeKey]: CheckboxPropControllerDataV1Type,
       value
@@ -701,15 +781,15 @@ function createCheckboxPropControllerDataFromBoolean(value, definition) {
 }
 
 // src/date/date.ts
-var import_zod7 = require("zod");
-var import_ts_pattern5 = require("ts-pattern");
-var datePropControllerDataV0Schema = import_zod7.z.string();
+var import_zod8 = require("zod");
+var import_ts_pattern6 = require("ts-pattern");
+var datePropControllerDataV0Schema = import_zod8.z.string();
 var DatePropControllerDataV1Type = "prop-controllers::date::v1";
-var datePropControllerDataV1Schema = import_zod7.z.object({
-  [ControlDataTypeKey]: import_zod7.z.literal(DatePropControllerDataV1Type),
-  value: import_zod7.z.string()
+var datePropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(DatePropControllerDataV1Type),
+  value: import_zod8.z.string()
 });
-var datePropControllerDataSchema = import_zod7.z.union([
+var datePropControllerDataSchema = import_zod8.z.union([
   datePropControllerDataV0Schema,
   datePropControllerDataV1Schema
 ]);
@@ -717,15 +797,15 @@ function Date(options = {}) {
   return { type: Types.Date, version: 1, options };
 }
 function getDatePropControllerDataString(data) {
-  return (0, import_ts_pattern5.match)(data).with(
+  return (0, import_ts_pattern6.match)(data).with(
     { [ControlDataTypeKey]: DatePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createDatePropControllerDataFromString(value, definition) {
-  return (0, import_ts_pattern5.match)(definition).with(
+  return (0, import_ts_pattern6.match)(definition).with(
     { version: 1 },
-    import_ts_pattern5.P.nullish,
+    import_ts_pattern6.P.nullish,
     () => ({
       [ControlDataTypeKey]: DatePropControllerDataV1Type,
       value
@@ -734,16 +814,16 @@ function createDatePropControllerDataFromString(value, definition) {
 }
 
 // src/element-id/element-id.ts
-var import_zod8 = require("zod");
-var import_ts_pattern6 = require("ts-pattern");
-var elementIDSchema = import_zod8.z.string();
+var import_zod9 = require("zod");
+var import_ts_pattern7 = require("ts-pattern");
+var elementIDSchema = import_zod9.z.string();
 var elementIDPropControllerDataV0Schema = elementIDSchema;
 var ElementIDPropControllerDataV1Type = "prop-controllers::element-id::v1";
-var elementIDPropControllerDataV1Schema = import_zod8.z.object({
-  [ControlDataTypeKey]: import_zod8.z.literal(ElementIDPropControllerDataV1Type),
+var elementIDPropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(ElementIDPropControllerDataV1Type),
   value: elementIDSchema
 });
-var elementIDPropControllerDataSchema = import_zod8.z.union([
+var elementIDPropControllerDataSchema = import_zod9.z.union([
   elementIDPropControllerDataV0Schema,
   elementIDPropControllerDataV1Schema
 ]);
@@ -751,15 +831,15 @@ function ElementID(options = {}) {
   return { type: Types.ElementID, version: 1, options };
 }
 function getElementIDPropControllerDataElementID(data) {
-  return (0, import_ts_pattern6.match)(data).with(
+  return (0, import_ts_pattern7.match)(data).with(
     { [ControlDataTypeKey]: ElementIDPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createElementIDPropControllerDataFromElementID(value, definition) {
-  return (0, import_ts_pattern6.match)(definition).with(
+  return (0, import_ts_pattern7.match)(definition).with(
     { version: 1 },
-    import_ts_pattern6.P.nullish,
+    import_ts_pattern7.P.nullish,
     () => ({
       [ControlDataTypeKey]: ElementIDPropControllerDataV1Type,
       value
@@ -775,7 +855,7 @@ function copyElementID(data, context) {
   return data;
 }
 function copyElementIDPropControllerData(data, context) {
-  return (0, import_ts_pattern6.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ElementIDPropControllerDataV1Type }, (v1) => {
+  return (0, import_ts_pattern7.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ElementIDPropControllerDataV1Type }, (v1) => {
     const value = copyElementID(v1.value, context);
     if (value == null)
       return void 0;
@@ -787,17 +867,17 @@ function copyElementIDPropControllerData(data, context) {
 }
 
 // src/font/font.ts
-var import_ts_pattern7 = require("ts-pattern");
-var import_zod9 = require("zod");
-var fontDataSchema = import_zod9.z.string();
+var import_ts_pattern8 = require("ts-pattern");
+var import_zod10 = require("zod");
+var fontDataSchema = import_zod10.z.string();
 var responsiveFontDataSchema = createResponsiveValueSchema(fontDataSchema);
 var fontPropControllerDataV0Schema = responsiveFontDataSchema;
 var FontPropControllerDataV1Type = "prop-controllers::font::v1";
-var fontPropControllerDataV1Schema = import_zod9.z.object({
-  [ControlDataTypeKey]: import_zod9.z.literal(FontPropControllerDataV1Type),
+var fontPropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(FontPropControllerDataV1Type),
   value: responsiveFontDataSchema
 });
-var fontPropControllerDataSchema = import_zod9.z.union([
+var fontPropControllerDataSchema = import_zod10.z.union([
   fontPropControllerDataV0Schema,
   fontPropControllerDataV1Schema
 ]);
@@ -805,15 +885,15 @@ function Font(options = {}) {
   return { type: Types.Font, version: 1, options };
 }
 function getFontPropControllerDataResponsiveFontData(data) {
-  return (0, import_ts_pattern7.match)(data).with(
+  return (0, import_ts_pattern8.match)(data).with(
     { [ControlDataTypeKey]: FontPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createFontPropControllerDataFromResponsiveFontData(responsiveFontData, definition) {
-  return (0, import_ts_pattern7.match)(definition).with(
+  return (0, import_ts_pattern8.match)(definition).with(
     { version: 1 },
-    import_ts_pattern7.P.nullish,
+    import_ts_pattern8.P.nullish,
     () => ({
       [ControlDataTypeKey]: FontPropControllerDataV1Type,
       value: responsiveFontData
@@ -821,38 +901,6 @@ function createFontPropControllerDataFromResponsiveFontData(responsiveFontData,
   ).otherwise(() => responsiveFontData);
 }
 
-// src/gap-x/gap-x.ts
-var import_ts_pattern8 = require("ts-pattern");
-var import_zod10 = require("zod");
-var gapXPropControllerDataV0Schema = responsiveGapDataSchema;
-var GapXPropControllerDataV1Type = "prop-controllers::gap-x::v1";
-var gapXPropControllerDataV1Schema = import_zod10.z.object({
-  [ControlDataTypeKey]: import_zod10.z.literal(GapXPropControllerDataV1Type),
-  value: responsiveGapDataSchema
-});
-var gapXPropControllerDataSchema = import_zod10.z.union([
-  gapXPropControllerDataV0Schema,
-  gapXPropControllerDataV1Schema
-]);
-function GapX(options = {}) {
-  return { type: Types.GapX, version: 1, options };
-}
-function getGapXPropControllerDataResponsiveGapData(data) {
-  return (0, import_ts_pattern8.match)(data).with(
-    { [ControlDataTypeKey]: GapXPropControllerDataV1Type },
-    (v1) => v1.value
-  ).otherwise((v0) => v0);
-}
-function createGapXPropControllerDataFromResponsiveGapData(responsiveGapData, definition) {
-  return (0, import_ts_pattern8.match)(definition).with(
-    { version: 1 },
-    () => ({
-      [ControlDataTypeKey]: GapXPropControllerDataV1Type,
-      value: responsiveGapData
-    })
-  ).otherwise(() => responsiveGapData);
-}
-
 // src/gap-y/gap-y.ts
 var import_ts_pattern9 = require("ts-pattern");
 var import_zod11 = require("zod");
@@ -2079,6 +2127,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Backgrounds,
+  BackgroundsPropControllerDataV2Type,
   Border,
   BorderPropControllerFormat,
   BorderRadius,
@@ -2100,9 +2149,11 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   Number,
   Padding,
   PaddingPropControllerFormat,
+  PropDef,
   ResponsiveColor,
   ResponsiveLength,
   ResponsiveLengthPropControllerDataV1Type,
+  ResponsiveNumber,
   Shadows,
   Table,
   TableFormFields,
@@ -2112,10 +2163,12 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   Video,
   Width,
   WidthPropControllerFormat,
+  backgroundImageDataSchema,
   backgroundsPropControllerDataSchema,
   borderPropControllerDataSchema,
   borderRadiusPropControllerDataSchema,
   checkboxPropControllerDataSchema,
+  colorDataSchema,
   copyBackgroundsPropControllerData,
   copyBorderPropControllerData,
   copyElementIDPropControllerData,
@@ -2135,7 +2188,6 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createDatePropControllerDataFromString,
   createElementIDPropControllerDataFromElementID,
   createFontPropControllerDataFromResponsiveFontData,
-  createGapXPropControllerDataFromResponsiveGapData,
   createGapYPropControllerDataFromResponsiveGapData,
   createGridPropControllerDataFromGridData,
   createImagePropControllerDataFromImageData,
@@ -2161,7 +2213,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   elementIDPropControllerDataSchema,
   elementSchema,
   fontPropControllerDataSchema,
-  gapXPropControllerDataSchema,
+  gapDataSchema,
   gapYPropControllerDataSchema,
   getBackgroundsPropControllerDataResponsiveBackgroundsData,
   getBackgroundsPropControllerFileIds,
@@ -2173,7 +2225,6 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getDatePropControllerDataString,
   getElementIDPropControllerDataElementID,
   getFontPropControllerDataResponsiveFontData,
-  getGapXPropControllerDataResponsiveGapData,
   getGapYPropControllerDataResponsiveGapData,
   getGridPropControllerDataGridData,
   getGridPropControllerElementChildren,
@@ -2204,8 +2255,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData,
   gridPropControllerDataSchema,
+  imageBackgroundDataSchema,
+  imageDataSchema,
+  imageDataV0Schema,
+  imageDataV1Schema,
   imagePropControllerDataSchema,
   imagesPropControllerDataSchema,
+  lengthDataSchema,
   linkDataSchema,
   linkPropControllerDataSchema,
   marginPropControllerDataSchema,
@@ -2214,12 +2270,15 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   numberPropControllerDataSchema,
   paddingPropControllerDataSchema,
   responsiveColorPropControllerDataSchema,
+  responsiveGapDataSchema,
   responsiveLengthPropControllerDataSchema,
+  responsiveNumberValueSchema,
   shadowsPropControllerDataSchema,
   tableFormFieldsPropControllerDataSchema,
   tablePropControllerDataSchema,
   textAreaPropControllerDataSchema,
   textStylePropControllerDataSchema,
+  versionedPropDef,
   videoPropControllerDataSchema,
   widthPropControllerDataSchema
 });