@makeswift/prop-controllers 0.0.2-canary.0 → 0.1.0-canary.2

package/dist/index.cjs

@@ -20,27 +20,393 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Border: () => Border,
+  BorderPropControllerFormat: () => BorderPropControllerFormat,
+  BorderRadius: () => BorderRadius,
+  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,
   Types: () => Types,
+  Video: () => Video,
+  Width: () => Width,
+  WidthPropControllerFormat: () => WidthPropControllerFormat,
+  borderPropControllerDataSchema: () => borderPropControllerDataSchema,
+  borderRadiusPropControllerDataSchema: () => borderRadiusPropControllerDataSchema,
+  checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
+  copyBorderPropControllerData: () => copyBorderPropControllerData,
   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,
+  createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
+  createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
+  datePropControllerDataSchema: () => datePropControllerDataSchema,
+  fontPropControllerDataSchema: () => fontPropControllerDataSchema,
+  getBorderPropControllerDataResponsiveBorderData: () => getBorderPropControllerDataResponsiveBorderData,
+  getBorderPropControllerDataSwatchIds: () => getBorderPropControllerDataSwatchIds,
+  getBorderRadiusPropControllerDataResponsiveBorderRadiusData: () => getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
+  getCheckboxPropControllerDataBoolean: () => getCheckboxPropControllerDataBoolean,
+  getDatePropControllerDataString: () => getDatePropControllerDataString,
+  getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
   getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
-  getLinkPropControllerValue: () => getLinkPropControllerValue
+  getLinkPropControllerValue: () => getLinkPropControllerValue,
+  getMarginPropControllerDataResponsiveMarginData: () => getMarginPropControllerDataResponsiveMarginData,
+  getNumberPropControllerDataNumber: () => getNumberPropControllerDataNumber,
+  getPaddingPropControllerDataResponsivePaddingData: () => getPaddingPropControllerDataResponsivePaddingData,
+  getResponsiveColorDataSwatchIds: () => getResponsiveColorDataSwatchIds,
+  getResponsiveColorPropControllerDataResponsiveColorData: () => getResponsiveColorPropControllerDataResponsiveColorData,
+  getResponsiveColorPropControllerDataSawtchIds: () => getResponsiveColorPropControllerDataSawtchIds,
+  getResponsiveLengthPropControllerDataResponsiveLengthData: () => getResponsiveLengthPropControllerDataResponsiveLengthData,
+  getShadowsPropControllerDataResponsiveShadowsData: () => getShadowsPropControllerDataResponsiveShadowsData,
+  getShadowsPropControllerDataSwatchIds: () => getShadowsPropControllerDataSwatchIds,
+  getTablePropControllerDataTableId: () => getTablePropControllerDataTableId,
+  getTablePropControllerDataTableIds: () => getTablePropControllerDataTableIds,
+  getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
+  getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
+  marginPropControllerDataSchema: () => marginPropControllerDataSchema,
+  numberPropControllerDataSchema: () => numberPropControllerDataSchema,
+  paddingPropControllerDataSchema: () => paddingPropControllerDataSchema,
+  responsiveColorPropControllerDataSchema: () => responsiveColorPropControllerDataSchema,
+  responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
+  shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema,
+  tablePropControllerDataSchema: () => tablePropControllerDataSchema,
+  videoPropControllerDataSchema: () => videoPropControllerDataSchema,
+  widthPropControllerDataSchema: () => widthPropControllerDataSchema
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/border/border.ts
+var import_ts_pattern = require("ts-pattern");
+
+// src/data.ts
+var import_zod = require("zod");
+var colorDataSchema = import_zod.z.object({
+  swatchId: import_zod.z.string(),
+  alpha: import_zod.z.number()
+});
+var lengthDataSchema = import_zod.z.object({
+  value: import_zod.z.number(),
+  unit: import_zod.z.union([import_zod.z.literal("px"), import_zod.z.literal("%")])
+});
+
 // src/prop-controllers.ts
+var import_zod2 = require("zod");
 var Types = {
-  Link: "Link"
+  Border: "Border",
+  BorderRadius: "BorderRadius",
+  Checkbox: "Checkbox",
+  Date: "Date",
+  Font: "Font",
+  Link: "Link",
+  Margin: "Margin",
+  Padding: "Padding",
+  Number: "Number",
+  Shadows: "Shadows",
+  ResponsiveColor: "ResponsiveColor",
+  ResponsiveLength: "ResponsiveLength",
+  Table: "Table",
+  Width: "Width",
+  Video: "Video"
 };
 var ControlDataTypeKey = "@@makeswift/type";
+var deviceSchema = import_zod2.z.string();
+function createDeviceOverrideSchema(schema) {
+  return import_zod2.z.object({
+    deviceId: deviceSchema,
+    value: schema
+  });
+}
+function createResponsiveValueSchema(schema) {
+  return import_zod2.z.array(createDeviceOverrideSchema(schema));
+}
+
+// src/border/border.ts
+var import_zod3 = require("zod");
+var borderSideDataSchema = import_zod3.z.object({
+  width: import_zod3.z.number().nullable().optional(),
+  style: import_zod3.z.enum(["dashed", "dotted", "solid"]),
+  color: colorDataSchema.nullable().optional()
+}).transform((v) => ({
+  ...v,
+  width: v.width
+}));
+var borderDataSchema = import_zod3.z.object({
+  borderTop: borderSideDataSchema.nullable().optional(),
+  borderRight: borderSideDataSchema.nullable().optional(),
+  borderBottom: borderSideDataSchema.nullable().optional(),
+  borderLeft: borderSideDataSchema.nullable().optional()
+}).transform((v) => ({
+  borderTop: v.borderTop,
+  borderRight: v.borderRight,
+  borderBottom: v.borderBottom,
+  borderLeft: v.borderLeft
+}));
+var responsiveBorderDataSchema = createResponsiveValueSchema(borderDataSchema);
+var borderPropControllerDataV0Schema = responsiveBorderDataSchema;
+var BorderPropControllerDataV1Type = "prop-controllers::border::v1";
+var borderPropControllerDataV1Schema = import_zod3.z.object({
+  [ControlDataTypeKey]: import_zod3.z.literal(BorderPropControllerDataV1Type),
+  value: responsiveBorderDataSchema
+});
+var borderPropControllerDataSchema = import_zod3.z.union([
+  borderPropControllerDataV0Schema,
+  borderPropControllerDataV1Schema
+]);
+var BorderPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::border::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::border::format::responsive-value"
+};
+function Border(options = {}) {
+  return { type: Types.Border, version: 1, options };
+}
+Border.Format = BorderPropControllerFormat;
+function getBorderPropControllerDataResponsiveBorderData(data) {
+  return (0, import_ts_pattern.match)(data).with(
+    { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createBorderPropControllerDataFromResponsiveBorderData(definition, responsiveBorderData) {
+  return (0, import_ts_pattern.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: BorderPropControllerDataV1Type,
+      value: responsiveBorderData
+    })
+  ).otherwise(() => responsiveBorderData);
+}
+function getBorderPropControllerDataSwatchIds(data) {
+  return getBorderPropControllerDataResponsiveBorderData(data)?.flatMap((override) => override.value).flatMap((borderValue) => {
+    return [
+      borderValue.borderTop?.color?.swatchId,
+      borderValue.borderRight?.color?.swatchId,
+      borderValue.borderBottom?.color?.swatchId,
+      borderValue.borderLeft?.color?.swatchId
+    ].filter(
+      (swatchId) => swatchId != null
+    );
+  }) ?? [];
+}
+function copyResponsiveBorderData(data, context) {
+  return data.map((override) => ({
+    ...override,
+    value: copyBorderValue(override.value)
+  }));
+  function copyBorderValue({
+    borderTop,
+    borderRight,
+    borderBottom,
+    borderLeft
+  }) {
+    return {
+      borderTop: borderTop && copyBorderSide(borderTop),
+      borderRight: borderRight && copyBorderSide(borderRight),
+      borderBottom: borderBottom && copyBorderSide(borderBottom),
+      borderLeft: borderLeft && copyBorderSide(borderLeft)
+    };
+  }
+  function copyBorderSide(borderSide) {
+    const { color } = borderSide;
+    if (color == null)
+      return borderSide;
+    return {
+      ...borderSide,
+      color: {
+        ...color,
+        swatchId: context.replacementContext.swatchIds.get(color.swatchId) ?? color.swatchId
+      }
+    };
+  }
+}
+function copyBorderPropControllerData(data, context) {
+  return (0, import_ts_pattern.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: BorderPropControllerDataV1Type,
+      value: copyResponsiveBorderData(v1.value, context)
+    })
+  ).otherwise((v0) => copyResponsiveBorderData(v0, context));
+}
+
+// src/border-radius/border-radius.ts
+var import_zod4 = require("zod");
+var import_ts_pattern2 = require("ts-pattern");
+var borderRadiusDataSchema = import_zod4.z.object({
+  borderTopLeftRadius: lengthDataSchema.nullable().optional(),
+  borderTopRightRadius: lengthDataSchema.nullable().optional(),
+  borderBottomLeftRadius: lengthDataSchema.nullable().optional(),
+  borderBottomRightRadius: lengthDataSchema.nullable().optional()
+});
+var responsiveBorderRadiusDataSchema = createResponsiveValueSchema(
+  borderRadiusDataSchema
+);
+var borderRadiusPropControllerDataV0Schema = responsiveBorderRadiusDataSchema;
+var BorderRadiusPropControllerDataV1Type = "prop-controllers::border-radius::v1";
+var borderRadiusPropControllerDataV1Schema = import_zod4.z.object({
+  [ControlDataTypeKey]: import_zod4.z.literal(BorderRadiusPropControllerDataV1Type),
+  value: responsiveBorderRadiusDataSchema
+});
+var borderRadiusPropControllerDataSchema = import_zod4.z.union([
+  borderRadiusPropControllerDataV0Schema,
+  borderRadiusPropControllerDataV1Schema
+]);
+var BorderRadiusPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::border-radius::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::border-radius::format::responsive-value"
+};
+function BorderRadius(options = {}) {
+  return { type: Types.BorderRadius, version: 1, options };
+}
+BorderRadius.Format = BorderRadiusPropControllerFormat;
+function getBorderRadiusPropControllerDataResponsiveBorderRadiusData(data) {
+  return (0, import_ts_pattern2.match)(data).with(
+    { [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(definition, responsiveBorderRadiusData) {
+  return (0, import_ts_pattern2.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type,
+      value: responsiveBorderRadiusData
+    })
+  ).otherwise(() => responsiveBorderRadiusData);
+}
+
+// src/checkbox/checkbox.ts
+var import_zod5 = require("zod");
+var import_ts_pattern3 = require("ts-pattern");
+var checkboxPropControllerDataV0Schema = import_zod5.z.boolean();
+var CheckboxPropControllerDataV1Type = "prop-controllers::checkbox::v1";
+var checkboxPropControllerDataV1Schema = import_zod5.z.object({
+  [ControlDataTypeKey]: import_zod5.z.literal(CheckboxPropControllerDataV1Type),
+  value: import_zod5.z.boolean()
+});
+var checkboxPropControllerDataSchema = import_zod5.z.union([
+  checkboxPropControllerDataV0Schema,
+  checkboxPropControllerDataV1Schema
+]);
+function Checkbox(options) {
+  return { type: Types.Checkbox, version: 1, options };
+}
+function getCheckboxPropControllerDataBoolean(data) {
+  return (0, import_ts_pattern3.match)(data).with(
+    { [ControlDataTypeKey]: CheckboxPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createCheckboxPropControllerDataFromBoolean(value, definition) {
+  return (0, import_ts_pattern3.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern3.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: CheckboxPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// 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_pattern = require("ts-pattern");
+var import_ts_pattern6 = require("ts-pattern");
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
 function getLinkPropControllerValue(data) {
-  return (0, import_ts_pattern.match)(data).with(
+  return (0, import_ts_pattern6.match)(data).with(
     { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
@@ -94,7 +460,7 @@ function copyLinkPropControllerData(data, context) {
       break;
     }
   }
-  return (0, import_ts_pattern.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
+  return (0, import_ts_pattern6.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
     ...v1,
     value
   })).otherwise((_) => value);
@@ -102,13 +468,542 @@ function copyLinkPropControllerData(data, context) {
 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_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_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod9.z.number()
+});
+var numberPropControllerDataSchema = import_zod9.z.union([
+  numberPropControllerDataV0Schema,
+  numberPropControllerDataV1Schema
+]);
+function Number(options = {}) {
+  return { type: Types.Number, version: 1, options };
+}
+function getNumberPropControllerDataNumber(data) {
+  return (0, import_ts_pattern8.match)(data).with(
+    { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createNumberPropControllerDataFromNumber(value, definition) {
+  return (0, import_ts_pattern8.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern8.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: NumberPropControllerDataV1Type,
+      value
+    })
+  ).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_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_zod11.z.object({
+  [ControlDataTypeKey]: import_zod11.z.literal(ResponsiveColorPropControllerDataV1Type),
+  value: responsiveColorDataSchema
+});
+var responsiveColorPropControllerDataSchema = import_zod11.z.union([
+  responsiveColorPropControllerDataV0Schema,
+  responsiveColorPropControllerDataV1Schema
+]);
+function ResponsiveColor(options = {}) {
+  return { type: Types.ResponsiveColor, version: 1, options };
+}
+function getResponsiveColorPropControllerDataResponsiveColorData(data) {
+  return (0, import_ts_pattern10.match)(data).with(
+    { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
+  return (0, import_ts_pattern10.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
+      value: responsiveColorData
+    })
+  ).otherwise(() => responsiveColorData);
+}
+function getResponsiveColorDataSwatchIds(data) {
+  return data.map((override) => override.value.swatchId);
+}
+function getResponsiveColorPropControllerDataSawtchIds(data) {
+  if (data == null)
+    return [];
+  return getResponsiveColorDataSwatchIds(
+    getResponsiveColorPropControllerDataResponsiveColorData(data)
+  );
+}
+function copyResponsiveColorData(data, context) {
+  return data.map((override) => ({
+    ...override,
+    value: copyColorValue(override.value)
+  }));
+  function copyColorValue(colorValue) {
+    return {
+      ...colorValue,
+      swatchId: context.replacementContext.swatchIds.get(colorValue.swatchId) ?? colorValue.swatchId
+    };
+  }
+}
+function copyResponsiveColorPropControllerData(data, context) {
+  return (0, import_ts_pattern10.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
+      value: copyResponsiveColorData(v1.value, context)
+    })
+  ).otherwise((v0) => copyResponsiveColorData(v0, context));
+}
+
+// src/responsive-length.ts
+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_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(ResponsiveLengthPropControllerDataV1Type),
+  value: responsiveLengthDataSchema
+});
+var responsiveLengthPropControllerDataSchema = import_zod12.z.union([
+  responsiveLengthPropControllerDataV0Schema,
+  responsiveLengthPropControllerDataV1Schema
+]);
+function ResponsiveLength(options = {}) {
+  return { type: Types.ResponsiveLength, version: 1, options };
+}
+function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
+  return (0, import_ts_pattern11.match)(data).with(
+    { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
+  return (0, import_ts_pattern11.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
+      value: responsiveLengthData
+    })
+  ).otherwise(() => responsiveLengthData);
+}
+
+// src/shadows.ts
+var import_ts_pattern12 = require("ts-pattern");
+var import_zod13 = require("zod");
+var shadowDataSchema = import_zod13.z.object({
+  color: colorDataSchema.nullable().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_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_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(ShadowsPropControllerDataV1Type),
+  value: responsiveShadowsDataSchema
+});
+var shadowsPropControllerDataSchema = import_zod13.z.union([
+  shadowsPropControllerDataV0Schema,
+  shadowsPropControllerDataV1Schema
+]);
+var ShadowsPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::shadows::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::shadows::format::responsive-value"
+};
+function Shadows(options = {}) {
+  return { type: Types.Shadows, version: 1, options };
+}
+Shadows.Format = ShadowsPropControllerFormat;
+function getShadowsPropControllerDataResponsiveShadowsData(data) {
+  return (0, import_ts_pattern12.match)(data).with(
+    { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
+  return (0, import_ts_pattern12.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
+      value: responsiveShadowsData
+    })
+  ).otherwise(() => responsiveShadowsData);
+}
+function getShadowsPropControllerDataSwatchIds(data) {
+  return getShadowsPropControllerDataResponsiveShadowsData(data)?.flatMap((override) => override.value).map((item) => item.payload.color?.swatchId).filter(
+    (swatchId) => swatchId != null
+  ) ?? [];
+}
+function copyResponsiveShadowsData(data, context) {
+  return data.map((override) => ({
+    ...override,
+    value: override.value.map((item) => {
+      const { color } = item.payload;
+      if (color == null)
+        return item;
+      return {
+        ...item,
+        payload: {
+          ...item.payload,
+          color: {
+            ...color,
+            swatchId: context.replacementContext.swatchIds.get(color.swatchId) ?? color.swatchId
+          }
+        }
+      };
+    })
+  }));
+}
+function copyShadowsPropControllerData(data, context) {
+  return (0, import_ts_pattern12.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
+      value: copyResponsiveShadowsData(v1.value, 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/width/width.ts
+var import_ts_pattern14 = require("ts-pattern");
+var import_zod15 = require("zod");
+var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
+var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
+var widthPropControllerDataV1Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(WidthPropControllerDataV1Type),
+  value: responsiveLengthDataSchema
+});
+var widthPropControllerDataSchema = import_zod15.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_pattern14.match)(data).with(
+    { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
+  return (0, import_ts_pattern14.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern14.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: WidthPropControllerDataV1Type,
+      value: responsiveLengthData
+    })
+  ).otherwise(() => responsiveLengthData);
+}
+
+// src/video/video.ts
+var import_zod16 = require("zod");
+var import_ts_pattern15 = require("ts-pattern");
+var videoDataSchema = import_zod16.z.object({
+  url: import_zod16.z.string().optional(),
+  muted: import_zod16.z.boolean().optional(),
+  playing: import_zod16.z.boolean().optional(),
+  loop: import_zod16.z.boolean().optional(),
+  controls: import_zod16.z.boolean().optional()
+});
+var videoPropControllerDataV0Schema = videoDataSchema;
+var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
+var videoPropControllerDataV1Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(VideoPropControllerDataV1Type),
+  value: videoDataSchema
+});
+var videoPropControllerDataSchema = import_zod16.z.union([
+  videoPropControllerDataV1Schema,
+  videoPropControllerDataV0Schema
+]);
+function Video(options = {}) {
+  return { type: Types.Video, version: 1, options };
+}
+function getVideoPropControllerDataVideoData(data) {
+  return (0, import_ts_pattern15.match)(data).with(
+    { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createVideoPropControllerDataFromVideoData(value, definition) {
+  return (0, import_ts_pattern15.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern15.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: VideoPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Border,
+  BorderPropControllerFormat,
+  BorderRadius,
+  BorderRadiusPropControllerFormat,
+  Checkbox,
   ControlDataTypeKey,
+  Date,
+  Font,
   Link,
   LinkPropControllerDataV1Type,
+  Margin,
+  MarginPropControllerFormat,
+  Number,
+  Padding,
+  PaddingPropControllerFormat,
+  ResponsiveColor,
+  ResponsiveLength,
+  ResponsiveLengthPropControllerDataV1Type,
+  Shadows,
+  Table,
   Types,
+  Video,
+  Width,
+  WidthPropControllerFormat,
+  borderPropControllerDataSchema,
+  borderRadiusPropControllerDataSchema,
+  checkboxPropControllerDataSchema,
+  copyBorderPropControllerData,
   copyLinkPropControllerData,
+  copyResponsiveColorPropControllerData,
+  copyShadowsPropControllerData,
+  copyTablePropControllerData,
+  createBorderPropControllerDataFromResponsiveBorderData,
+  createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
+  createCheckboxPropControllerDataFromBoolean,
+  createDatePropControllerDataFromString,
+  createFontPropControllerDataFromResponsiveFontData,
+  createMarginPropControllerDataFromResponsiveMarginData,
+  createNumberPropControllerDataFromNumber,
+  createPaddingPropControllerDataFromResponsivePaddingData,
+  createResponsiveColorPropControllerDataFromResponsiveColorData,
+  createResponsiveLengthPropControllerDataFromResponsiveLengthData,
+  createResponsiveValueSchema,
+  createShadowsPropControllerDataFromResponsiveShadowsData,
+  createTablePropControllerDataFromTableId,
+  createVideoPropControllerDataFromVideoData,
+  createWidthPropControllerDataFromResponsiveLengthData,
+  datePropControllerDataSchema,
+  fontPropControllerDataSchema,
+  getBorderPropControllerDataResponsiveBorderData,
+  getBorderPropControllerDataSwatchIds,
+  getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
+  getCheckboxPropControllerDataBoolean,
+  getDatePropControllerDataString,
+  getFontPropControllerDataResponsiveFontData,
   getLinkPropControllerPageIds,
-  getLinkPropControllerValue
+  getLinkPropControllerValue,
+  getMarginPropControllerDataResponsiveMarginData,
+  getNumberPropControllerDataNumber,
+  getPaddingPropControllerDataResponsivePaddingData,
+  getResponsiveColorDataSwatchIds,
+  getResponsiveColorPropControllerDataResponsiveColorData,
+  getResponsiveColorPropControllerDataSawtchIds,
+  getResponsiveLengthPropControllerDataResponsiveLengthData,
+  getShadowsPropControllerDataResponsiveShadowsData,
+  getShadowsPropControllerDataSwatchIds,
+  getTablePropControllerDataTableId,
+  getTablePropControllerDataTableIds,
+  getVideoPropControllerDataVideoData,
+  getWidthPropControllerDataResponsiveLengthData,
+  marginPropControllerDataSchema,
+  numberPropControllerDataSchema,
+  paddingPropControllerDataSchema,
+  responsiveColorPropControllerDataSchema,
+  responsiveLengthPropControllerDataSchema,
+  shadowsPropControllerDataSchema,
+  tablePropControllerDataSchema,
+  videoPropControllerDataSchema,
+  widthPropControllerDataSchema
 });