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

package/dist/index.cjs

@@ -20,27 +20,285 @@ 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,
   Link: () => Link,
   LinkPropControllerDataV1Type: () => LinkPropControllerDataV1Type,
+  Number: () => Number,
+  ResponsiveColor: () => ResponsiveColor,
+  ResponsiveLength: () => ResponsiveLength,
+  ResponsiveLengthPropControllerDataV1Type: () => ResponsiveLengthPropControllerDataV1Type,
+  Shadows: () => Shadows,
   Types: () => Types,
+  borderPropControllerDataSchema: () => borderPropControllerDataSchema,
+  borderRadiusPropControllerDataSchema: () => borderRadiusPropControllerDataSchema,
+  checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
+  copyBorderPropControllerData: () => copyBorderPropControllerData,
   copyLinkPropControllerData: () => copyLinkPropControllerData,
+  copyResponsiveColorPropControllerData: () => copyResponsiveColorPropControllerData,
+  copyShadowsPropControllerData: () => copyShadowsPropControllerData,
+  createBorderPropControllerDataFromResponsiveBorderData: () => createBorderPropControllerDataFromResponsiveBorderData,
+  createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData: () => createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
+  createCheckboxPropControllerDataFromBoolean: () => createCheckboxPropControllerDataFromBoolean,
+  createNumberPropControllerDataFromNumber: () => createNumberPropControllerDataFromNumber,
+  createResponsiveColorPropControllerDataFromResponsiveColorData: () => createResponsiveColorPropControllerDataFromResponsiveColorData,
+  createResponsiveLengthPropControllerDataFromResponsiveLengthData: () => createResponsiveLengthPropControllerDataFromResponsiveLengthData,
+  createResponsiveValueSchema: () => createResponsiveValueSchema,
+  createShadowsPropControllerDataFromResponsiveShadowsData: () => createShadowsPropControllerDataFromResponsiveShadowsData,
+  getBorderPropControllerDataResponsiveBorderData: () => getBorderPropControllerDataResponsiveBorderData,
+  getBorderPropControllerDataSwatchIds: () => getBorderPropControllerDataSwatchIds,
+  getBorderRadiusPropControllerDataResponsiveBorderRadiusData: () => getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
+  getCheckboxPropControllerDataBoolean: () => getCheckboxPropControllerDataBoolean,
   getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
-  getLinkPropControllerValue: () => getLinkPropControllerValue
+  getLinkPropControllerValue: () => getLinkPropControllerValue,
+  getNumberPropControllerDataNumber: () => getNumberPropControllerDataNumber,
+  getResponsiveColorDataSwatchIds: () => getResponsiveColorDataSwatchIds,
+  getResponsiveColorPropControllerDataResponsiveColorData: () => getResponsiveColorPropControllerDataResponsiveColorData,
+  getResponsiveColorPropControllerDataSawtchIds: () => getResponsiveColorPropControllerDataSawtchIds,
+  getResponsiveLengthPropControllerDataResponsiveLengthData: () => getResponsiveLengthPropControllerDataResponsiveLengthData,
+  getShadowsPropControllerDataResponsiveShadowsData: () => getShadowsPropControllerDataResponsiveShadowsData,
+  getShadowsPropControllerDataSwatchIds: () => getShadowsPropControllerDataSwatchIds,
+  numberPropControllerDataSchema: () => numberPropControllerDataSchema,
+  responsiveColorPropControllerDataSchema: () => responsiveColorPropControllerDataSchema,
+  responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
+  shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema
 });
 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",
+  Link: "Link",
+  Number: "Number",
+  Shadows: "Shadows",
+  ResponsiveColor: "ResponsiveColor",
+  ResponsiveLength: "ResponsiveLength"
 };
 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/link/link.ts
-var import_ts_pattern = require("ts-pattern");
+var import_ts_pattern4 = require("ts-pattern");
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
 function getLinkPropControllerValue(data) {
-  return (0, import_ts_pattern.match)(data).with(
+  return (0, import_ts_pattern4.match)(data).with(
     { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
@@ -94,7 +352,7 @@ function copyLinkPropControllerData(data, context) {
       break;
     }
   }
-  return (0, import_ts_pattern.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
+  return (0, import_ts_pattern4.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
     ...v1,
     value
   })).otherwise((_) => value);
@@ -102,13 +360,268 @@ function copyLinkPropControllerData(data, context) {
 function Link(options = {}) {
   return { type: Types.Link, version: 1, options };
 }
+
+// src/number.ts
+var import_zod6 = require("zod");
+var import_ts_pattern5 = require("ts-pattern");
+var numberPropControllerDataV0Schema = import_zod6.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 numberPropControllerDataSchema = import_zod6.z.union([
+  numberPropControllerDataV0Schema,
+  numberPropControllerDataV1Schema
+]);
+function Number(options = {}) {
+  return { type: Types.Number, version: 1, options };
+}
+function getNumberPropControllerDataNumber(data) {
+  return (0, import_ts_pattern5.match)(data).with(
+    { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createNumberPropControllerDataFromNumber(value, definition) {
+  return (0, import_ts_pattern5.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern5.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: NumberPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/responsive-color.ts
+var import_zod7 = require("zod");
+var import_ts_pattern6 = 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),
+  value: responsiveColorDataSchema
+});
+var responsiveColorPropControllerDataSchema = import_zod7.z.union([
+  responsiveColorPropControllerDataV0Schema,
+  responsiveColorPropControllerDataV1Schema
+]);
+function ResponsiveColor(options = {}) {
+  return { type: Types.ResponsiveColor, version: 1, options };
+}
+function getResponsiveColorPropControllerDataResponsiveColorData(data) {
+  return (0, import_ts_pattern6.match)(data).with(
+    { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
+  return (0, import_ts_pattern6.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_pattern6.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_zod8 = require("zod");
+var import_ts_pattern7 = 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),
+  value: responsiveLengthDataSchema
+});
+var responsiveLengthPropControllerDataSchema = import_zod8.z.union([
+  responsiveLengthPropControllerDataV0Schema,
+  responsiveLengthPropControllerDataV1Schema
+]);
+function ResponsiveLength(options = {}) {
+  return { type: Types.ResponsiveLength, version: 1, options };
+}
+function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
+  return (0, import_ts_pattern7.match)(data).with(
+    { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
+  return (0, import_ts_pattern7.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
+      value: responsiveLengthData
+    })
+  ).otherwise(() => responsiveLengthData);
+}
+
+// src/shadows.ts
+var import_ts_pattern8 = require("ts-pattern");
+var import_zod9 = require("zod");
+var shadowDataSchema = import_zod9.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()
+});
+var shadowsDataSchema = import_zod9.z.array(
+  import_zod9.z.object({
+    id: import_zod9.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),
+  value: responsiveShadowsDataSchema
+});
+var shadowsPropControllerDataSchema = import_zod9.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_pattern8.match)(data).with(
+    { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
+  return (0, import_ts_pattern8.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_pattern8.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
+      value: copyResponsiveShadowsData(v1.value, context)
+    })
+  ).otherwise((v0) => copyResponsiveShadowsData(v0, context));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Border,
+  BorderPropControllerFormat,
+  BorderRadius,
+  BorderRadiusPropControllerFormat,
+  Checkbox,
   ControlDataTypeKey,
   Link,
   LinkPropControllerDataV1Type,
+  Number,
+  ResponsiveColor,
+  ResponsiveLength,
+  ResponsiveLengthPropControllerDataV1Type,
+  Shadows,
   Types,
+  borderPropControllerDataSchema,
+  borderRadiusPropControllerDataSchema,
+  checkboxPropControllerDataSchema,
+  copyBorderPropControllerData,
   copyLinkPropControllerData,
+  copyResponsiveColorPropControllerData,
+  copyShadowsPropControllerData,
+  createBorderPropControllerDataFromResponsiveBorderData,
+  createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
+  createCheckboxPropControllerDataFromBoolean,
+  createNumberPropControllerDataFromNumber,
+  createResponsiveColorPropControllerDataFromResponsiveColorData,
+  createResponsiveLengthPropControllerDataFromResponsiveLengthData,
+  createResponsiveValueSchema,
+  createShadowsPropControllerDataFromResponsiveShadowsData,
+  getBorderPropControllerDataResponsiveBorderData,
+  getBorderPropControllerDataSwatchIds,
+  getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
+  getCheckboxPropControllerDataBoolean,
   getLinkPropControllerPageIds,
-  getLinkPropControllerValue
+  getLinkPropControllerValue,
+  getNumberPropControllerDataNumber,
+  getResponsiveColorDataSwatchIds,
+  getResponsiveColorPropControllerDataResponsiveColorData,
+  getResponsiveColorPropControllerDataSawtchIds,
+  getResponsiveLengthPropControllerDataResponsiveLengthData,
+  getShadowsPropControllerDataResponsiveShadowsData,
+  getShadowsPropControllerDataSwatchIds,
+  numberPropControllerDataSchema,
+  responsiveColorPropControllerDataSchema,
+  responsiveLengthPropControllerDataSchema,
+  shadowsPropControllerDataSchema
 });