@makeswift/prop-controllers 0.1.0-canary.1 → 0.1.0-canary.3

package/dist/index.cjs

@@ -26,14 +26,25 @@ __export(src_exports, {
   BorderRadiusPropControllerFormat: () => BorderRadiusPropControllerFormat,
   Checkbox: () => Checkbox,
   ControlDataTypeKey: () => ControlDataTypeKey,
+  Date: () => Date,
+  Font: () => Font,
   Link: () => Link,
   LinkPropControllerDataV1Type: () => LinkPropControllerDataV1Type,
+  Margin: () => Margin,
+  MarginPropControllerFormat: () => MarginPropControllerFormat,
   Number: () => Number,
+  Padding: () => Padding,
+  PaddingPropControllerFormat: () => PaddingPropControllerFormat,
   ResponsiveColor: () => ResponsiveColor,
   ResponsiveLength: () => ResponsiveLength,
   ResponsiveLengthPropControllerDataV1Type: () => ResponsiveLengthPropControllerDataV1Type,
   Shadows: () => Shadows,
+  Table: () => Table,
+  TextStyle: () => TextStyle,
   Types: () => Types,
+  Video: () => Video,
+  Width: () => Width,
+  WidthPropControllerFormat: () => WidthPropControllerFormat,
   borderPropControllerDataSchema: () => borderPropControllerDataSchema,
   borderRadiusPropControllerDataSchema: () => borderRadiusPropControllerDataSchema,
   checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
@@ -41,31 +52,57 @@ __export(src_exports, {
   copyLinkPropControllerData: () => copyLinkPropControllerData,
   copyResponsiveColorPropControllerData: () => copyResponsiveColorPropControllerData,
   copyShadowsPropControllerData: () => copyShadowsPropControllerData,
+  copyTablePropControllerData: () => copyTablePropControllerData,
   createBorderPropControllerDataFromResponsiveBorderData: () => createBorderPropControllerDataFromResponsiveBorderData,
   createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData: () => createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
   createCheckboxPropControllerDataFromBoolean: () => createCheckboxPropControllerDataFromBoolean,
+  createDatePropControllerDataFromString: () => createDatePropControllerDataFromString,
+  createFontPropControllerDataFromResponsiveFontData: () => createFontPropControllerDataFromResponsiveFontData,
+  createMarginPropControllerDataFromResponsiveMarginData: () => createMarginPropControllerDataFromResponsiveMarginData,
   createNumberPropControllerDataFromNumber: () => createNumberPropControllerDataFromNumber,
+  createPaddingPropControllerDataFromResponsivePaddingData: () => createPaddingPropControllerDataFromResponsivePaddingData,
   createResponsiveColorPropControllerDataFromResponsiveColorData: () => createResponsiveColorPropControllerDataFromResponsiveColorData,
   createResponsiveLengthPropControllerDataFromResponsiveLengthData: () => createResponsiveLengthPropControllerDataFromResponsiveLengthData,
   createResponsiveValueSchema: () => createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData: () => createShadowsPropControllerDataFromResponsiveShadowsData,
+  createTablePropControllerDataFromTableId: () => createTablePropControllerDataFromTableId,
+  createTextStylePropControllerDataFromResponsiveTextStyleData: () => createTextStylePropControllerDataFromResponsiveTextStyleData,
+  createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
+  createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
+  datePropControllerDataSchema: () => datePropControllerDataSchema,
+  fontPropControllerDataSchema: () => fontPropControllerDataSchema,
   getBorderPropControllerDataResponsiveBorderData: () => getBorderPropControllerDataResponsiveBorderData,
   getBorderPropControllerDataSwatchIds: () => getBorderPropControllerDataSwatchIds,
   getBorderRadiusPropControllerDataResponsiveBorderRadiusData: () => getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
   getCheckboxPropControllerDataBoolean: () => getCheckboxPropControllerDataBoolean,
+  getDatePropControllerDataString: () => getDatePropControllerDataString,
+  getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
   getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
   getLinkPropControllerValue: () => getLinkPropControllerValue,
+  getMarginPropControllerDataResponsiveMarginData: () => getMarginPropControllerDataResponsiveMarginData,
   getNumberPropControllerDataNumber: () => getNumberPropControllerDataNumber,
+  getPaddingPropControllerDataResponsivePaddingData: () => getPaddingPropControllerDataResponsivePaddingData,
   getResponsiveColorDataSwatchIds: () => getResponsiveColorDataSwatchIds,
   getResponsiveColorPropControllerDataResponsiveColorData: () => getResponsiveColorPropControllerDataResponsiveColorData,
   getResponsiveColorPropControllerDataSawtchIds: () => getResponsiveColorPropControllerDataSawtchIds,
   getResponsiveLengthPropControllerDataResponsiveLengthData: () => getResponsiveLengthPropControllerDataResponsiveLengthData,
   getShadowsPropControllerDataResponsiveShadowsData: () => getShadowsPropControllerDataResponsiveShadowsData,
   getShadowsPropControllerDataSwatchIds: () => getShadowsPropControllerDataSwatchIds,
+  getTablePropControllerDataTableId: () => getTablePropControllerDataTableId,
+  getTablePropControllerDataTableIds: () => getTablePropControllerDataTableIds,
+  getTextStylePropControllerDataResponsiveTextStyleData: () => getTextStylePropControllerDataResponsiveTextStyleData,
+  getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
+  getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
+  marginPropControllerDataSchema: () => marginPropControllerDataSchema,
   numberPropControllerDataSchema: () => numberPropControllerDataSchema,
+  paddingPropControllerDataSchema: () => paddingPropControllerDataSchema,
   responsiveColorPropControllerDataSchema: () => responsiveColorPropControllerDataSchema,
   responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
-  shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema
+  shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema,
+  tablePropControllerDataSchema: () => tablePropControllerDataSchema,
+  textStylePropControllerDataSchema: () => textStylePropControllerDataSchema,
+  videoPropControllerDataSchema: () => videoPropControllerDataSchema,
+  widthPropControllerDataSchema: () => widthPropControllerDataSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -89,11 +126,19 @@ var Types = {
   Border: "Border",
   BorderRadius: "BorderRadius",
   Checkbox: "Checkbox",
+  Date: "Date",
+  Font: "Font",
   Link: "Link",
+  Margin: "Margin",
+  Padding: "Padding",
   Number: "Number",
   Shadows: "Shadows",
   ResponsiveColor: "ResponsiveColor",
-  ResponsiveLength: "ResponsiveLength"
+  ResponsiveLength: "ResponsiveLength",
+  Table: "Table",
+  TextStyle: "TextStyle",
+  Width: "Width",
+  Video: "Video"
 };
 var ControlDataTypeKey = "@@makeswift/type";
 var deviceSchema = import_zod2.z.string();
@@ -294,11 +339,79 @@ function createCheckboxPropControllerDataFromBoolean(value, definition) {
   ).otherwise(() => value);
 }
 
-// src/link/link.ts
+// src/date/date.ts
+var import_zod6 = require("zod");
 var import_ts_pattern4 = require("ts-pattern");
+var datePropControllerDataV0Schema = import_zod6.z.string();
+var DatePropControllerDataV1Type = "prop-controllers::date::v1";
+var datePropControllerDataV1Schema = import_zod6.z.object({
+  [ControlDataTypeKey]: import_zod6.z.literal(DatePropControllerDataV1Type),
+  value: import_zod6.z.string()
+});
+var datePropControllerDataSchema = import_zod6.z.union([
+  datePropControllerDataV0Schema,
+  datePropControllerDataV1Schema
+]);
+function Date(options = {}) {
+  return { type: Types.Date, version: 1, options };
+}
+function getDatePropControllerDataString(data) {
+  return (0, import_ts_pattern4.match)(data).with(
+    { [ControlDataTypeKey]: DatePropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createDatePropControllerDataFromString(value, definition) {
+  return (0, import_ts_pattern4.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern4.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: DatePropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/font/font.ts
+var import_ts_pattern5 = require("ts-pattern");
+var import_zod7 = require("zod");
+var fontDataSchema = import_zod7.z.string();
+var responsiveFontDataSchema = createResponsiveValueSchema(fontDataSchema);
+var fontPropControllerDataV0Schema = responsiveFontDataSchema;
+var FontPropControllerDataV1Type = "prop-controllers::font::v1";
+var fontPropControllerDataV1Schema = import_zod7.z.object({
+  [ControlDataTypeKey]: import_zod7.z.literal(FontPropControllerDataV1Type),
+  value: responsiveFontDataSchema
+});
+var fontPropControllerDataSchema = import_zod7.z.union([
+  fontPropControllerDataV0Schema,
+  fontPropControllerDataV1Schema
+]);
+function Font(options = {}) {
+  return { type: Types.Font, version: 1, options };
+}
+function getFontPropControllerDataResponsiveFontData(data) {
+  return (0, import_ts_pattern5.match)(data).with(
+    { [ControlDataTypeKey]: FontPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createFontPropControllerDataFromResponsiveFontData(responsiveFontData, definition) {
+  return (0, import_ts_pattern5.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern5.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: FontPropControllerDataV1Type,
+      value: responsiveFontData
+    })
+  ).otherwise(() => responsiveFontData);
+}
+
+// src/link/link.ts
+var import_ts_pattern6 = require("ts-pattern");
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
 function getLinkPropControllerValue(data) {
-  return (0, import_ts_pattern4.match)(data).with(
+  return (0, import_ts_pattern6.match)(data).with(
     { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
@@ -352,7 +465,7 @@ function copyLinkPropControllerData(data, context) {
       break;
     }
   }
-  return (0, import_ts_pattern4.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
+  return (0, import_ts_pattern6.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
     ...v1,
     value
   })).otherwise((_) => value);
@@ -361,16 +474,73 @@ function Link(options = {}) {
   return { type: Types.Link, version: 1, options };
 }
 
+// src/margin/margin.ts
+var import_ts_pattern7 = require("ts-pattern");
+var import_zod8 = require("zod");
+var marginSideDataSchema = import_zod8.z.union([
+  import_zod8.z.object({
+    value: import_zod8.z.number(),
+    unit: import_zod8.z.literal("px")
+  }),
+  import_zod8.z.literal("auto")
+]);
+var marginDataSchema = import_zod8.z.object({
+  marginTop: marginSideDataSchema.nullable().optional(),
+  marginRight: marginSideDataSchema.nullable().optional(),
+  marginBottom: marginSideDataSchema.nullable().optional(),
+  marginLeft: marginSideDataSchema.nullable().optional()
+}).transform((v) => ({
+  marginTop: v.marginTop,
+  marginRight: v.marginRight,
+  marginBottom: v.marginBottom,
+  marginLeft: v.marginLeft
+}));
+var responsiveMarginDataSchema = createResponsiveValueSchema(marginDataSchema);
+var marginPropControllerDataV0Schema = responsiveMarginDataSchema;
+var MarginPropControllerDataV1Type = "prop-controllers::margin::v1";
+var marginPropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(MarginPropControllerDataV1Type),
+  value: responsiveMarginDataSchema
+});
+var marginPropControllerDataSchema = import_zod8.z.union([
+  marginPropControllerDataV0Schema,
+  marginPropControllerDataV1Schema
+]);
+var MarginPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::margin::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::margin::format::responsive-value"
+};
+function Margin(options = {}) {
+  return { type: Types.Margin, version: 1, options };
+}
+Margin.Format = MarginPropControllerFormat;
+function getMarginPropControllerDataResponsiveMarginData(data) {
+  return (0, import_ts_pattern7.match)(data).with(
+    { [ControlDataTypeKey]: MarginPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createMarginPropControllerDataFromResponsiveMarginData(responsiveMarginData, definition) {
+  return (0, import_ts_pattern7.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern7.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: MarginPropControllerDataV1Type,
+      value: responsiveMarginData
+    })
+  ).otherwise(() => responsiveMarginData);
+}
+
 // src/number.ts
-var import_zod6 = require("zod");
-var import_ts_pattern5 = require("ts-pattern");
-var numberPropControllerDataV0Schema = import_zod6.z.number();
+var import_zod9 = require("zod");
+var import_ts_pattern8 = require("ts-pattern");
+var numberPropControllerDataV0Schema = import_zod9.z.number();
 var NumberPropControllerDataV1Type = "prop-controllers::number::v1";
-var numberPropControllerDataV1Schema = import_zod6.z.object({
-  [ControlDataTypeKey]: import_zod6.z.literal(NumberPropControllerDataV1Type),
-  value: import_zod6.z.number()
+var numberPropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod9.z.number()
 });
-var numberPropControllerDataSchema = import_zod6.z.union([
+var numberPropControllerDataSchema = import_zod9.z.union([
   numberPropControllerDataV0Schema,
   numberPropControllerDataV1Schema
 ]);
@@ -378,15 +548,15 @@ function Number(options = {}) {
   return { type: Types.Number, version: 1, options };
 }
 function getNumberPropControllerDataNumber(data) {
-  return (0, import_ts_pattern5.match)(data).with(
+  return (0, import_ts_pattern8.match)(data).with(
     { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createNumberPropControllerDataFromNumber(value, definition) {
-  return (0, import_ts_pattern5.match)(definition).with(
+  return (0, import_ts_pattern8.match)(definition).with(
     { version: 1 },
-    import_ts_pattern5.P.nullish,
+    import_ts_pattern8.P.nullish,
     () => ({
       [ControlDataTypeKey]: NumberPropControllerDataV1Type,
       value
@@ -394,17 +564,71 @@ function createNumberPropControllerDataFromNumber(value, definition) {
   ).otherwise(() => value);
 }
 
+// src/padding/padding.ts
+var import_ts_pattern9 = require("ts-pattern");
+var import_zod10 = require("zod");
+var paddingSideDataSchema = import_zod10.z.object({
+  value: import_zod10.z.number(),
+  unit: import_zod10.z.literal("px")
+});
+var paddingDataSchema = import_zod10.z.object({
+  paddingTop: paddingSideDataSchema.nullable().optional(),
+  paddingRight: paddingSideDataSchema.nullable().optional(),
+  paddingBottom: paddingSideDataSchema.nullable().optional(),
+  paddingLeft: paddingSideDataSchema.nullable().optional()
+}).transform((v) => ({
+  paddingTop: v.paddingTop,
+  paddingRight: v.paddingRight,
+  paddingBottom: v.paddingBottom,
+  paddingLeft: v.paddingLeft
+}));
+var responsivePaddingDataSchema = createResponsiveValueSchema(paddingDataSchema);
+var paddingPropControllerDataV0Schema = responsivePaddingDataSchema;
+var PaddingPropControllerDataV1Type = "prop-controllers::padding::v1";
+var paddingPropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(PaddingPropControllerDataV1Type),
+  value: responsivePaddingDataSchema
+});
+var paddingPropControllerDataSchema = import_zod10.z.union([
+  paddingPropControllerDataV0Schema,
+  paddingPropControllerDataV1Schema
+]);
+var PaddingPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::padding::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::padding::format::responsive-value"
+};
+function Padding(options = {}) {
+  return { type: Types.Padding, version: 1, options };
+}
+Padding.Format = PaddingPropControllerFormat;
+function getPaddingPropControllerDataResponsivePaddingData(data) {
+  return (0, import_ts_pattern9.match)(data).with(
+    { [ControlDataTypeKey]: PaddingPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createPaddingPropControllerDataFromResponsivePaddingData(responsivePaddingData, definition) {
+  return (0, import_ts_pattern9.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern9.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: PaddingPropControllerDataV1Type,
+      value: responsivePaddingData
+    })
+  ).otherwise(() => responsivePaddingData);
+}
+
 // src/responsive-color.ts
-var import_zod7 = require("zod");
-var import_ts_pattern6 = require("ts-pattern");
+var import_zod11 = require("zod");
+var import_ts_pattern10 = require("ts-pattern");
 var responsiveColorDataSchema = createResponsiveValueSchema(colorDataSchema);
 var responsiveColorPropControllerDataV0Schema = responsiveColorDataSchema;
 var ResponsiveColorPropControllerDataV1Type = "prop-controllers::responsive-color::v1";
-var responsiveColorPropControllerDataV1Schema = import_zod7.z.object({
-  [ControlDataTypeKey]: import_zod7.z.literal(ResponsiveColorPropControllerDataV1Type),
+var responsiveColorPropControllerDataV1Schema = import_zod11.z.object({
+  [ControlDataTypeKey]: import_zod11.z.literal(ResponsiveColorPropControllerDataV1Type),
   value: responsiveColorDataSchema
 });
-var responsiveColorPropControllerDataSchema = import_zod7.z.union([
+var responsiveColorPropControllerDataSchema = import_zod11.z.union([
   responsiveColorPropControllerDataV0Schema,
   responsiveColorPropControllerDataV1Schema
 ]);
@@ -412,13 +636,13 @@ function ResponsiveColor(options = {}) {
   return { type: Types.ResponsiveColor, version: 1, options };
 }
 function getResponsiveColorPropControllerDataResponsiveColorData(data) {
-  return (0, import_ts_pattern6.match)(data).with(
+  return (0, import_ts_pattern10.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
-  return (0, import_ts_pattern6.match)(definition).with(
+  return (0, import_ts_pattern10.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -449,7 +673,7 @@ function copyResponsiveColorData(data, context) {
   }
 }
 function copyResponsiveColorPropControllerData(data, context) {
-  return (0, import_ts_pattern6.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern10.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -459,16 +683,16 @@ function copyResponsiveColorPropControllerData(data, context) {
 }
 
 // src/responsive-length.ts
-var import_zod8 = require("zod");
-var import_ts_pattern7 = require("ts-pattern");
+var import_zod12 = require("zod");
+var import_ts_pattern11 = require("ts-pattern");
 var responsiveLengthDataSchema = createResponsiveValueSchema(lengthDataSchema);
 var responsiveLengthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var ResponsiveLengthPropControllerDataV1Type = "prop-controllers::responsive-length::v1";
-var responsiveLengthPropControllerDataV1Schema = import_zod8.z.object({
-  [ControlDataTypeKey]: import_zod8.z.literal(ResponsiveLengthPropControllerDataV1Type),
+var responsiveLengthPropControllerDataV1Schema = import_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(ResponsiveLengthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var responsiveLengthPropControllerDataSchema = import_zod8.z.union([
+var responsiveLengthPropControllerDataSchema = import_zod12.z.union([
   responsiveLengthPropControllerDataV0Schema,
   responsiveLengthPropControllerDataV1Schema
 ]);
@@ -476,13 +700,13 @@ function ResponsiveLength(options = {}) {
   return { type: Types.ResponsiveLength, version: 1, options };
 }
 function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern7.match)(data).with(
+  return (0, import_ts_pattern11.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
-  return (0, import_ts_pattern7.match)(definition).with(
+  return (0, import_ts_pattern11.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
@@ -492,30 +716,30 @@ function createResponsiveLengthPropControllerDataFromResponsiveLengthData(defini
 }
 
 // src/shadows.ts
-var import_ts_pattern8 = require("ts-pattern");
-var import_zod9 = require("zod");
-var shadowDataSchema = import_zod9.z.object({
+var import_ts_pattern12 = require("ts-pattern");
+var import_zod13 = require("zod");
+var shadowDataSchema = import_zod13.z.object({
   color: colorDataSchema.nullable().optional(),
-  blurRadius: import_zod9.z.number().optional(),
-  spreadRadius: import_zod9.z.number().optional(),
-  offsetX: import_zod9.z.number().optional(),
-  offsetY: import_zod9.z.number().optional(),
-  inset: import_zod9.z.boolean().optional()
+  blurRadius: import_zod13.z.number().optional(),
+  spreadRadius: import_zod13.z.number().optional(),
+  offsetX: import_zod13.z.number().optional(),
+  offsetY: import_zod13.z.number().optional(),
+  inset: import_zod13.z.boolean().optional()
 });
-var shadowsDataSchema = import_zod9.z.array(
-  import_zod9.z.object({
-    id: import_zod9.z.string(),
+var shadowsDataSchema = import_zod13.z.array(
+  import_zod13.z.object({
+    id: import_zod13.z.string(),
     payload: shadowDataSchema
   })
 );
 var responsiveShadowsDataSchema = createResponsiveValueSchema(shadowsDataSchema);
 var shadowsPropControllerDataV0Schema = responsiveShadowsDataSchema;
 var ShadowsPropControllerDataV1Type = "prop-controllers::shadows::v1";
-var shadowsPropControllerDataV1Schema = import_zod9.z.object({
-  [ControlDataTypeKey]: import_zod9.z.literal(ShadowsPropControllerDataV1Type),
+var shadowsPropControllerDataV1Schema = import_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(ShadowsPropControllerDataV1Type),
   value: responsiveShadowsDataSchema
 });
-var shadowsPropControllerDataSchema = import_zod9.z.union([
+var shadowsPropControllerDataSchema = import_zod13.z.union([
   shadowsPropControllerDataV0Schema,
   shadowsPropControllerDataV1Schema
 ]);
@@ -528,13 +752,13 @@ function Shadows(options = {}) {
 }
 Shadows.Format = ShadowsPropControllerFormat;
 function getShadowsPropControllerDataResponsiveShadowsData(data) {
-  return (0, import_ts_pattern8.match)(data).with(
+  return (0, import_ts_pattern12.match)(data).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
-  return (0, import_ts_pattern8.match)(definition).with(
+  return (0, import_ts_pattern12.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -568,7 +792,7 @@ function copyResponsiveShadowsData(data, context) {
   }));
 }
 function copyShadowsPropControllerData(data, context) {
-  return (0, import_ts_pattern8.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern12.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -576,6 +800,187 @@ function copyShadowsPropControllerData(data, context) {
     })
   ).otherwise((v0) => copyResponsiveShadowsData(v0, context));
 }
+
+// src/table/table.ts
+var import_zod14 = require("zod");
+var import_ts_pattern13 = require("ts-pattern");
+var tableIdSchema = import_zod14.z.string();
+var tablePropControllerDataV0Schema = tableIdSchema;
+var TablePropControllerDataV1Type = "prop-controllers::table::v1";
+var tablePropControllerDataV1Schema = import_zod14.z.object({
+  [ControlDataTypeKey]: import_zod14.z.literal(TablePropControllerDataV1Type),
+  value: tableIdSchema
+});
+var tablePropControllerDataSchema = import_zod14.z.union([
+  tablePropControllerDataV0Schema,
+  tablePropControllerDataV1Schema
+]);
+function Table(options = {}) {
+  return { type: Types.Table, version: 1, options };
+}
+function getTablePropControllerDataTableId(data) {
+  return (0, import_ts_pattern13.match)(data).with(
+    { [ControlDataTypeKey]: TablePropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTablePropControllerDataFromTableId(value, definition) {
+  return (0, import_ts_pattern13.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern13.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: TablePropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+function copyTableId(data, context) {
+  if (data == null)
+    return data;
+  return context.replacementContext.tableIds.get(data) ?? data;
+}
+function copyTablePropControllerData(data, context) {
+  return (0, import_ts_pattern13.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: TablePropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: TablePropControllerDataV1Type,
+      value: copyTableId(v1.value, context)
+    })
+  ).otherwise((v0) => copyTableId(v0, context));
+}
+function getTablePropControllerDataTableIds(data) {
+  const value = getTablePropControllerDataTableId(data);
+  return value ? [value] : [];
+}
+
+// src/text-style/text-style.ts
+var import_ts_pattern14 = require("ts-pattern");
+var import_zod15 = require("zod");
+var textStyleDataSchema = import_zod15.z.object({
+  fontFamily: import_zod15.z.string().optional().nullable(),
+  letterSpacing: import_zod15.z.number().optional().nullable(),
+  fontSize: import_zod15.z.object({
+    value: import_zod15.z.number(),
+    unit: import_zod15.z.literal("px")
+  }).optional().nullable(),
+  fontWeight: import_zod15.z.number().optional().nullable(),
+  textTransform: import_zod15.z.array(import_zod15.z.literal("uppercase")),
+  fontStyle: import_zod15.z.array(import_zod15.z.literal("italic"))
+}).transform((v) => ({
+  ...v,
+  letterSpacing: v.letterSpacing,
+  fontSize: v.fontSize,
+  fontWeight: v.fontWeight,
+  textTransform: v.textTransform,
+  fontStyle: v.fontStyle
+}));
+var responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
+var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
+var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
+var textStylePropControllerDataV1Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(TextStylePropControllerDataV1Type),
+  value: responsiveTextStyleDataSchema
+});
+var textStylePropControllerDataSchema = import_zod15.z.union([
+  textStylePropControllerDataV0Schema,
+  textStylePropControllerDataV1Schema
+]);
+function TextStyle(options = {}) {
+  return { type: Types.TextStyle, version: 1, options };
+}
+function getTextStylePropControllerDataResponsiveTextStyleData(data) {
+  return (0, import_ts_pattern14.match)(data).with(
+    { [ControlDataTypeKey]: TextStylePropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTextStylePropControllerDataFromResponsiveTextStyleData(responsiveTextStyleData, definition) {
+  return (0, import_ts_pattern14.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: TextStylePropControllerDataV1Type,
+      value: responsiveTextStyleData
+    })
+  ).otherwise(() => responsiveTextStyleData);
+}
+
+// src/width/width.ts
+var import_ts_pattern15 = require("ts-pattern");
+var import_zod16 = require("zod");
+var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
+var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
+var widthPropControllerDataV1Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(WidthPropControllerDataV1Type),
+  value: responsiveLengthDataSchema
+});
+var widthPropControllerDataSchema = import_zod16.z.union([
+  widthPropControllerDataV0Schema,
+  widthPropControllerDataV1Schema
+]);
+var WidthPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::width::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::width::format::responsive-value"
+};
+function Width(options = {}) {
+  return { type: Types.Width, version: 1, options };
+}
+Width.Format = WidthPropControllerFormat;
+function getWidthPropControllerDataResponsiveLengthData(data) {
+  return (0, import_ts_pattern15.match)(data).with(
+    { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
+  return (0, import_ts_pattern15.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern15.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: WidthPropControllerDataV1Type,
+      value: responsiveLengthData
+    })
+  ).otherwise(() => responsiveLengthData);
+}
+
+// src/video/video.ts
+var import_zod17 = require("zod");
+var import_ts_pattern16 = require("ts-pattern");
+var videoDataSchema = import_zod17.z.object({
+  url: import_zod17.z.string().optional(),
+  muted: import_zod17.z.boolean().optional(),
+  playing: import_zod17.z.boolean().optional(),
+  loop: import_zod17.z.boolean().optional(),
+  controls: import_zod17.z.boolean().optional()
+});
+var videoPropControllerDataV0Schema = videoDataSchema;
+var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
+var videoPropControllerDataV1Schema = import_zod17.z.object({
+  [ControlDataTypeKey]: import_zod17.z.literal(VideoPropControllerDataV1Type),
+  value: videoDataSchema
+});
+var videoPropControllerDataSchema = import_zod17.z.union([
+  videoPropControllerDataV1Schema,
+  videoPropControllerDataV0Schema
+]);
+function Video(options = {}) {
+  return { type: Types.Video, version: 1, options };
+}
+function getVideoPropControllerDataVideoData(data) {
+  return (0, import_ts_pattern16.match)(data).with(
+    { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createVideoPropControllerDataFromVideoData(value, definition) {
+  return (0, import_ts_pattern16.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern16.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: VideoPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Border,
@@ -584,14 +989,25 @@ function copyShadowsPropControllerData(data, context) {
   BorderRadiusPropControllerFormat,
   Checkbox,
   ControlDataTypeKey,
+  Date,
+  Font,
   Link,
   LinkPropControllerDataV1Type,
+  Margin,
+  MarginPropControllerFormat,
   Number,
+  Padding,
+  PaddingPropControllerFormat,
   ResponsiveColor,
   ResponsiveLength,
   ResponsiveLengthPropControllerDataV1Type,
   Shadows,
+  Table,
+  TextStyle,
   Types,
+  Video,
+  Width,
+  WidthPropControllerFormat,
   borderPropControllerDataSchema,
   borderRadiusPropControllerDataSchema,
   checkboxPropControllerDataSchema,
@@ -599,29 +1015,55 @@ function copyShadowsPropControllerData(data, context) {
   copyLinkPropControllerData,
   copyResponsiveColorPropControllerData,
   copyShadowsPropControllerData,
+  copyTablePropControllerData,
   createBorderPropControllerDataFromResponsiveBorderData,
   createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
   createCheckboxPropControllerDataFromBoolean,
+  createDatePropControllerDataFromString,
+  createFontPropControllerDataFromResponsiveFontData,
+  createMarginPropControllerDataFromResponsiveMarginData,
   createNumberPropControllerDataFromNumber,
+  createPaddingPropControllerDataFromResponsivePaddingData,
   createResponsiveColorPropControllerDataFromResponsiveColorData,
   createResponsiveLengthPropControllerDataFromResponsiveLengthData,
   createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData,
+  createTablePropControllerDataFromTableId,
+  createTextStylePropControllerDataFromResponsiveTextStyleData,
+  createVideoPropControllerDataFromVideoData,
+  createWidthPropControllerDataFromResponsiveLengthData,
+  datePropControllerDataSchema,
+  fontPropControllerDataSchema,
   getBorderPropControllerDataResponsiveBorderData,
   getBorderPropControllerDataSwatchIds,
   getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
   getCheckboxPropControllerDataBoolean,
+  getDatePropControllerDataString,
+  getFontPropControllerDataResponsiveFontData,
   getLinkPropControllerPageIds,
   getLinkPropControllerValue,
+  getMarginPropControllerDataResponsiveMarginData,
   getNumberPropControllerDataNumber,
+  getPaddingPropControllerDataResponsivePaddingData,
   getResponsiveColorDataSwatchIds,
   getResponsiveColorPropControllerDataResponsiveColorData,
   getResponsiveColorPropControllerDataSawtchIds,
   getResponsiveLengthPropControllerDataResponsiveLengthData,
   getShadowsPropControllerDataResponsiveShadowsData,
   getShadowsPropControllerDataSwatchIds,
+  getTablePropControllerDataTableId,
+  getTablePropControllerDataTableIds,
+  getTextStylePropControllerDataResponsiveTextStyleData,
+  getVideoPropControllerDataVideoData,
+  getWidthPropControllerDataResponsiveLengthData,
+  marginPropControllerDataSchema,
   numberPropControllerDataSchema,
+  paddingPropControllerDataSchema,
   responsiveColorPropControllerDataSchema,
   responsiveLengthPropControllerDataSchema,
-  shadowsPropControllerDataSchema
+  shadowsPropControllerDataSchema,
+  tablePropControllerDataSchema,
+  textStylePropControllerDataSchema,
+  videoPropControllerDataSchema,
+  widthPropControllerDataSchema
 });