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

package/dist/index.cjs

@@ -49,10 +49,13 @@ __export(src_exports, {
   ResponsiveLengthPropControllerDataV1Type: () => ResponsiveLengthPropControllerDataV1Type,
   ResponsiveNumber: () => ResponsiveNumber,
   ResponsiveOpacity: () => ResponsiveOpacity,
+  ResponsiveSelect: () => ResponsiveSelect,
   Shadows: () => Shadows,
+  SocialLinks: () => SocialLinks,
   Table: () => Table,
   TableFormFields: () => TableFormFields,
   TextArea: () => TextArea,
+  TextInput: () => TextInput,
   TextStyle: () => TextStyle,
   Types: () => Types,
   Video: () => Video,
@@ -96,9 +99,11 @@ __export(src_exports, {
   createResponsiveLengthPropControllerDataFromResponsiveLengthData: () => createResponsiveLengthPropControllerDataFromResponsiveLengthData,
   createResponsiveValueSchema: () => createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData: () => createShadowsPropControllerDataFromResponsiveShadowsData,
+  createSocialLinksPropControllerDataFromSocialLinksData: () => createSocialLinksPropControllerDataFromSocialLinksData,
   createTableFormFieldsPropControllerDataFromTableFormFieldsData: () => createTableFormFieldsPropControllerDataFromTableFormFieldsData,
   createTablePropControllerDataFromTableId: () => createTablePropControllerDataFromTableId,
   createTextAreaPropControllerDataFromString: () => createTextAreaPropControllerDataFromString,
+  createTextInputPropControllerDataFromString: () => createTextInputPropControllerDataFromString,
   createTextStylePropControllerDataFromResponsiveTextStyleData: () => createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
@@ -142,10 +147,13 @@ __export(src_exports, {
   getResponsiveLengthPropControllerDataResponsiveLengthData: () => getResponsiveLengthPropControllerDataResponsiveLengthData,
   getShadowsPropControllerDataResponsiveShadowsData: () => getShadowsPropControllerDataResponsiveShadowsData,
   getShadowsPropControllerDataSwatchIds: () => getShadowsPropControllerDataSwatchIds,
+  getSocialLinkTypes: () => getSocialLinkTypes,
+  getSocialLinksPropControllerDataSocialLinksData: () => getSocialLinksPropControllerDataSocialLinksData,
   getTableFormFieldsPropControllerDataTableFormFieldsData: () => getTableFormFieldsPropControllerDataTableFormFieldsData,
   getTablePropControllerDataTableId: () => getTablePropControllerDataTableId,
   getTablePropControllerDataTableIds: () => getTablePropControllerDataTableIds,
   getTextAreaPropControllerDataString: () => getTextAreaPropControllerDataString,
+  getTextInputPropControllerDataString: () => getTextInputPropControllerDataString,
   getTextStylePropControllerDataResponsiveTextStyleData: () => getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
@@ -169,11 +177,15 @@ __export(src_exports, {
   responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
   responsiveNumberValueSchema: () => responsiveNumberValueSchema,
   responsiveOpacityValueSchema: () => responsiveOpacityValueSchema,
+  responsiveSelectValueSchema: () => responsiveSelectValueSchema,
   shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema,
+  socialLinksPropControllerDataSchema: () => socialLinksPropControllerDataSchema,
   tableFormFieldsPropControllerDataSchema: () => tableFormFieldsPropControllerDataSchema,
   tablePropControllerDataSchema: () => tablePropControllerDataSchema,
   textAreaPropControllerDataSchema: () => textAreaPropControllerDataSchema,
+  textInputPropControllerDataSchema: () => textInputPropControllerDataSchema,
   textStylePropControllerDataSchema: () => textStylePropControllerDataSchema,
+  typeArg: () => typeArg,
   versionedPropDef: () => versionedPropDef,
   videoPropControllerDataSchema: () => videoPropControllerDataSchema,
   widthPropControllerDataSchema: () => widthPropControllerDataSchema
@@ -208,7 +220,10 @@ var Types = {
   ResponsiveLength: "ResponsiveLength",
   ResponsiveNumber: "ResponsiveNumber",
   ResponsiveOpacity: "ResponsiveOpacity",
+  ResponsiveSelect: "ResponsiveSelect",
+  SocialLinks: "SocialLinks",
   TextArea: "TextArea",
+  TextInput: "TextInput",
   Table: "Table",
   TableFormFields: "TableFormFields",
   TextStyle: "TextStyle",
@@ -278,84 +293,101 @@ var imageDataSchema = import_zod2.z.union([imageDataV0Schema, imageDataV1Schema]
 var responsiveNumberValueSchema = createResponsiveValueSchema(
   import_zod2.z.number()
 );
+var responsiveSelectValueSchema = createResponsiveValueSchema(
+  import_zod2.z.string()
+);
 
 // src/versioned.ts
 var import_ts_pattern = require("ts-pattern");
 var import_zod3 = require("zod");
-var PropDef = class extends Function {
+var PropDef = class {
+  __associated_types__;
+};
+var TypeArg = class {
   __associated_types__;
-  _callable;
-  constructor() {
-    super("...args", "return this._callable.__call__(...args)");
-    this._callable = this.bind(this);
-    return this._callable;
-  }
 };
-var versionedPropDef = () => (type, valueSchema, discriminator) => {
+var typeArg = () => new TypeArg();
+var versionedPropDef = (type, valueSchema, discriminator2, _rawOptionsType, _ctor) => {
   const schemaV0 = valueSchema;
   const schemaV1 = import_zod3.z.object({
-    [ControlDataTypeKey]: import_zod3.z.literal(discriminator.dataKey),
+    [ControlDataTypeKey]: import_zod3.z.literal(discriminator2.dataKey),
     value: valueSchema
   });
   const schema = import_zod3.z.union([schemaV0, schemaV1]);
-  class Def extends PropDef {
-    schemaV0 = schemaV0;
-    schemaV1 = schemaV1;
-    schema = schema;
-    type = type;
-    discriminator = discriminator;
-    __call__(options) {
-      return {
-        type,
-        version: discriminator.version,
-        options: options ?? {}
-      };
-    }
-    fromPropData(propData) {
-      return (0, import_ts_pattern.match)(propData).with(
-        {
-          [ControlDataTypeKey]: discriminator.dataKey
-        },
-        (v1) => v1.value
-      ).otherwise((v0) => v0);
-    }
-    toPropData(data, descriptor) {
-      return (0, import_ts_pattern.match)(descriptor).with(
-        { version: discriminator.version },
-        () => ({
-          [ControlDataTypeKey]: discriminator.dataKey,
-          value: data
-        })
-      ).otherwise(() => data);
-    }
-  }
-  return new Def();
+  const r = (options) => {
+    return {
+      type,
+      version: discriminator2.version,
+      options: options ?? {}
+    };
+  };
+  r.schema = schema;
+  r.type = type;
+  r.discriminator = discriminator2;
+  r.fromPropData = (propData) => (0, import_ts_pattern.match)(propData).with(
+    {
+      [ControlDataTypeKey]: discriminator2.dataKey
+    },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+  r.toPropData = (data, descriptor) => (0, import_ts_pattern.match)(descriptor).with(
+    { version: discriminator2.version },
+    () => ({
+      [ControlDataTypeKey]: discriminator2.dataKey,
+      value: data
+    })
+  ).otherwise(() => data);
+  return r;
 };
 
 // src/gap-x/gap-x.ts
-var GapX = versionedPropDef()(Types.GapX, responsiveGapDataSchema, {
-  version: 1,
-  dataKey: "prop-controllers::gap-x::v1"
-});
+var GapX = versionedPropDef(
+  Types.GapX,
+  responsiveGapDataSchema,
+  {
+    version: 1,
+    dataKey: "prop-controllers::gap-x::v1"
+  },
+  typeArg()
+);
 
 // src/responsive-number/responsive-number.ts
-var ResponsiveNumber = versionedPropDef()(Types.ResponsiveNumber, responsiveNumberValueSchema, {
-  version: 1,
-  dataKey: "prop-controllers::responsive-number::v1"
-});
+var ResponsiveNumber = versionedPropDef(
+  Types.ResponsiveNumber,
+  responsiveNumberValueSchema,
+  {
+    version: 1,
+    dataKey: "prop-controllers::responsive-number::v1"
+  },
+  typeArg()
+);
 
 // src/responsive-opacity/responsive-opacity.ts
 var import_zod4 = require("zod");
 var responsiveOpacityValueSchema = createResponsiveValueSchema(
   import_zod4.z.number()
 );
-var ResponsiveOpacity = versionedPropDef()(
+var ResponsiveOpacity = versionedPropDef(
   Types.ResponsiveOpacity,
   responsiveOpacityValueSchema,
   {
     version: 1,
     dataKey: "prop-controllers::responsive-opacity::v1"
-  }
+  },
+  typeArg()
+);
+
+// src/responsive-select/responsive-select.ts
+var discriminator = {
+  version: 1,
+  dataKey: "prop-controllers::responsive-select::v1"
+};
+var ResponsiveSelect = versionedPropDef(
+  Types.ResponsiveSelect,
+  responsiveSelectValueSchema,
+  discriminator,
+  typeArg(),
+  typeArg()
 );
 
 // src/backgrounds/backgrounds.ts
@@ -1820,31 +1852,120 @@ function createResponsiveLengthPropControllerDataFromResponsiveLengthData(defini
   ).otherwise(() => responsiveLengthData);
 }
 
-// src/shadows.ts
-var import_ts_pattern21 = require("ts-pattern");
+// src/social-links/social-links.ts
 var import_zod24 = require("zod");
-var shadowDataSchema = import_zod24.z.object({
+var import_ts_pattern21 = require("ts-pattern");
+var socialLinkTypesV0 = [
+  "angellist",
+  "codepen",
+  "discord",
+  "dribbble",
+  "facebook",
+  "github",
+  "instagram",
+  "linkedin",
+  "medium",
+  "pinterest",
+  "reddit",
+  "rss",
+  "snapchat",
+  "soundcloud",
+  "spotify",
+  "telegram",
+  "tumblr",
+  "twitch",
+  "twitter",
+  "vimeo",
+  "whatsapp",
+  "yelp",
+  "youtube"
+];
+var socialLinkTypesV1 = [...socialLinkTypesV0, "x", "slack"];
+var socialLinkV0Schema = import_zod24.z.object({
+  type: import_zod24.z.enum(socialLinkTypesV0),
+  url: import_zod24.z.string()
+});
+var socialLinkV1Schema = import_zod24.z.object({
+  type: import_zod24.z.enum(socialLinkTypesV1),
+  url: import_zod24.z.string()
+});
+var socialLinksLinkV0Schema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  payload: socialLinkV0Schema
+});
+var socialLinksLinkV1Schema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  payload: socialLinkV1Schema
+});
+var socialLinksDataV0Schema = import_zod24.z.object({
+  links: import_zod24.z.array(socialLinksLinkV0Schema),
+  openInNewTab: import_zod24.z.boolean()
+});
+var socialLinksDataV1Schema = import_zod24.z.object({
+  links: import_zod24.z.array(socialLinksLinkV1Schema),
+  openInNewTab: import_zod24.z.boolean()
+});
+var socialLinksDataSchema = import_zod24.z.union([
+  socialLinksDataV0Schema,
+  socialLinksDataV1Schema
+]);
+var socialLinksPropControllerDataV1Schema = socialLinksDataSchema;
+var SocialLinksPropControllerDataV2Type = "prop-controllers::social-links::v2";
+var socialLinksPropControllerDataV2Schema = import_zod24.z.object({
+  [ControlDataTypeKey]: import_zod24.z.literal(SocialLinksPropControllerDataV2Type),
+  value: socialLinksDataSchema
+});
+var socialLinksPropControllerDataSchema = import_zod24.z.union([
+  socialLinksPropControllerDataV1Schema,
+  socialLinksPropControllerDataV2Schema
+]);
+function SocialLinks(options = {}) {
+  return { type: Types.SocialLinks, version: 2, options };
+}
+function getSocialLinkTypes(descriptor) {
+  return (0, import_ts_pattern21.match)(descriptor).with({ version: import_ts_pattern21.P.union(1, 2) }, () => socialLinkTypesV1).otherwise(() => socialLinkTypesV0);
+}
+function getSocialLinksPropControllerDataSocialLinksData(data) {
+  return (0, import_ts_pattern21.match)(data).with(
+    { [ControlDataTypeKey]: SocialLinksPropControllerDataV2Type },
+    (v2) => v2.value
+  ).otherwise((v0) => v0);
+}
+function createSocialLinksPropControllerDataFromSocialLinksData(data, definition) {
+  return (0, import_ts_pattern21.match)(definition).with(
+    { version: 2 },
+    () => ({
+      [ControlDataTypeKey]: SocialLinksPropControllerDataV2Type,
+      value: data
+    })
+  ).otherwise(() => data);
+}
+
+// src/shadows.ts
+var import_ts_pattern22 = require("ts-pattern");
+var import_zod25 = require("zod");
+var shadowDataSchema = import_zod25.z.object({
   color: colorDataSchema.nullable().optional(),
-  blurRadius: import_zod24.z.number().optional(),
-  spreadRadius: import_zod24.z.number().optional(),
-  offsetX: import_zod24.z.number().optional(),
-  offsetY: import_zod24.z.number().optional(),
-  inset: import_zod24.z.boolean().optional()
-});
-var shadowsDataSchema = import_zod24.z.array(
-  import_zod24.z.object({
-    id: import_zod24.z.string(),
+  blurRadius: import_zod25.z.number().optional(),
+  spreadRadius: import_zod25.z.number().optional(),
+  offsetX: import_zod25.z.number().optional(),
+  offsetY: import_zod25.z.number().optional(),
+  inset: import_zod25.z.boolean().optional()
+});
+var shadowsDataSchema = import_zod25.z.array(
+  import_zod25.z.object({
+    id: import_zod25.z.string(),
     payload: shadowDataSchema
   })
 );
 var responsiveShadowsDataSchema = createResponsiveValueSchema(shadowsDataSchema);
 var shadowsPropControllerDataV0Schema = responsiveShadowsDataSchema;
 var ShadowsPropControllerDataV1Type = "prop-controllers::shadows::v1";
-var shadowsPropControllerDataV1Schema = import_zod24.z.object({
-  [ControlDataTypeKey]: import_zod24.z.literal(ShadowsPropControllerDataV1Type),
+var shadowsPropControllerDataV1Schema = import_zod25.z.object({
+  [ControlDataTypeKey]: import_zod25.z.literal(ShadowsPropControllerDataV1Type),
   value: responsiveShadowsDataSchema
 });
-var shadowsPropControllerDataSchema = import_zod24.z.union([
+var shadowsPropControllerDataSchema = import_zod25.z.union([
   shadowsPropControllerDataV0Schema,
   shadowsPropControllerDataV1Schema
 ]);
@@ -1857,13 +1978,13 @@ function Shadows(options = {}) {
 }
 Shadows.Format = ShadowsPropControllerFormat;
 function getShadowsPropControllerDataResponsiveShadowsData(data) {
-  return (0, import_ts_pattern21.match)(data).with(
+  return (0, import_ts_pattern22.match)(data).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
-  return (0, import_ts_pattern21.match)(definition).with(
+  return (0, import_ts_pattern22.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1897,7 +2018,7 @@ function copyResponsiveShadowsData(data, context) {
   }));
 }
 function copyShadowsPropControllerData(data, context) {
-  return (0, import_ts_pattern21.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern22.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1907,16 +2028,16 @@ function copyShadowsPropControllerData(data, context) {
 }
 
 // src/table/table.ts
-var import_zod25 = require("zod");
-var import_ts_pattern22 = require("ts-pattern");
-var tableIdSchema = import_zod25.z.string();
+var import_zod26 = require("zod");
+var import_ts_pattern23 = require("ts-pattern");
+var tableIdSchema = import_zod26.z.string();
 var tablePropControllerDataV0Schema = tableIdSchema;
 var TablePropControllerDataV1Type = "prop-controllers::table::v1";
-var tablePropControllerDataV1Schema = import_zod25.z.object({
-  [ControlDataTypeKey]: import_zod25.z.literal(TablePropControllerDataV1Type),
+var tablePropControllerDataV1Schema = import_zod26.z.object({
+  [ControlDataTypeKey]: import_zod26.z.literal(TablePropControllerDataV1Type),
   value: tableIdSchema
 });
-var tablePropControllerDataSchema = import_zod25.z.union([
+var tablePropControllerDataSchema = import_zod26.z.union([
   tablePropControllerDataV0Schema,
   tablePropControllerDataV1Schema
 ]);
@@ -1924,15 +2045,15 @@ function Table(options = {}) {
   return { type: Types.Table, version: 1, options };
 }
 function getTablePropControllerDataTableId(data) {
-  return (0, import_ts_pattern22.match)(data).with(
+  return (0, import_ts_pattern23.match)(data).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTablePropControllerDataFromTableId(value, definition) {
-  return (0, import_ts_pattern22.match)(definition).with(
+  return (0, import_ts_pattern23.match)(definition).with(
     { version: 1 },
-    import_ts_pattern22.P.nullish,
+    import_ts_pattern23.P.nullish,
     () => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
       value
@@ -1945,7 +2066,7 @@ function copyTableId(data, context) {
   return context.replacementContext.tableIds.get(data) ?? data;
 }
 function copyTablePropControllerData(data, context) {
-  return (0, import_ts_pattern22.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern23.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
@@ -1959,36 +2080,36 @@ function getTablePropControllerDataTableIds(data) {
 }
 
 // src/table-form-fields/table-form-fields.ts
-var import_zod26 = require("zod");
-var import_ts_pattern23 = require("ts-pattern");
-var tableFormFieldSchema = import_zod26.z.object({
-  id: import_zod26.z.string(),
-  tableColumnId: import_zod26.z.string(),
-  label: import_zod26.z.string().optional(),
-  placeholder: import_zod26.z.string().optional(),
-  defaultValue: import_zod26.z.union([import_zod26.z.string(), import_zod26.z.boolean(), import_zod26.z.array(import_zod26.z.string())]).optional(),
-  required: import_zod26.z.boolean().optional(),
-  hidden: import_zod26.z.boolean().optional(),
-  type: import_zod26.z.union([import_zod26.z.literal("select"), import_zod26.z.literal("radio")]).optional(),
-  hideLabel: import_zod26.z.boolean().optional(),
-  autofill: import_zod26.z.boolean().optional()
-});
-var tableFormFieldsDataSchema = import_zod26.z.object({
-  fields: import_zod26.z.array(tableFormFieldSchema),
+var import_zod27 = require("zod");
+var import_ts_pattern24 = require("ts-pattern");
+var tableFormFieldSchema = import_zod27.z.object({
+  id: import_zod27.z.string(),
+  tableColumnId: import_zod27.z.string(),
+  label: import_zod27.z.string().optional(),
+  placeholder: import_zod27.z.string().optional(),
+  defaultValue: import_zod27.z.union([import_zod27.z.string(), import_zod27.z.boolean(), import_zod27.z.array(import_zod27.z.string())]).optional(),
+  required: import_zod27.z.boolean().optional(),
+  hidden: import_zod27.z.boolean().optional(),
+  type: import_zod27.z.union([import_zod27.z.literal("select"), import_zod27.z.literal("radio")]).optional(),
+  hideLabel: import_zod27.z.boolean().optional(),
+  autofill: import_zod27.z.boolean().optional()
+});
+var tableFormFieldsDataSchema = import_zod27.z.object({
+  fields: import_zod27.z.array(tableFormFieldSchema),
   grid: createResponsiveValueSchema(
-    import_zod26.z.object({
-      count: import_zod26.z.number(),
-      spans: import_zod26.z.array(import_zod26.z.array(import_zod26.z.number()))
+    import_zod27.z.object({
+      count: import_zod27.z.number(),
+      spans: import_zod27.z.array(import_zod27.z.array(import_zod27.z.number()))
     })
   )
 });
 var tableFormFieldsPropControllerDataV0Schema = tableFormFieldsDataSchema;
 var TableFormFieldsPropControllerDataV1Type = "prop-controllers::table-form-fields::v1";
-var tableFormFieldsPropControllerDataV1Schema = import_zod26.z.object({
-  [ControlDataTypeKey]: import_zod26.z.literal(TableFormFieldsPropControllerDataV1Type),
+var tableFormFieldsPropControllerDataV1Schema = import_zod27.z.object({
+  [ControlDataTypeKey]: import_zod27.z.literal(TableFormFieldsPropControllerDataV1Type),
   value: tableFormFieldsDataSchema
 });
-var tableFormFieldsPropControllerDataSchema = import_zod26.z.union([
+var tableFormFieldsPropControllerDataSchema = import_zod27.z.union([
   tableFormFieldsPropControllerDataV0Schema,
   tableFormFieldsPropControllerDataV1Schema
 ]);
@@ -1996,15 +2117,15 @@ function TableFormFields(options = {}) {
   return { type: Types.TableFormFields, version: 1, options };
 }
 function getTableFormFieldsPropControllerDataTableFormFieldsData(data) {
-  return (0, import_ts_pattern23.match)(data).with(
+  return (0, import_ts_pattern24.match)(data).with(
     { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTableFormFieldsPropControllerDataFromTableFormFieldsData(value, definition) {
-  return (0, import_ts_pattern23.match)(definition).with(
+  return (0, import_ts_pattern24.match)(definition).with(
     { version: 1 },
-    import_ts_pattern23.P.nullish,
+    import_ts_pattern24.P.nullish,
     () => ({
       [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
       value
@@ -2023,7 +2144,7 @@ function copyTableFormFieldsData(data, context) {
   };
 }
 function copyTableFormFieldsPropControllerData(data, context) {
-  return (0, import_ts_pattern23.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern24.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
@@ -2033,15 +2154,15 @@ function copyTableFormFieldsPropControllerData(data, context) {
 }
 
 // src/text-area/text-area.ts
-var import_zod27 = require("zod");
-var import_ts_pattern24 = require("ts-pattern");
-var textAreaPropControllerDataV0Schema = import_zod27.z.string();
+var import_zod28 = require("zod");
+var import_ts_pattern25 = require("ts-pattern");
+var textAreaPropControllerDataV0Schema = import_zod28.z.string();
 var TextAreaPropControllerDataV1Type = "prop-controllers::text-area::v1";
-var textAreaPropControllerDataV1Schema = import_zod27.z.object({
-  [ControlDataTypeKey]: import_zod27.z.literal(TextAreaPropControllerDataV1Type),
-  value: import_zod27.z.string()
+var textAreaPropControllerDataV1Schema = import_zod28.z.object({
+  [ControlDataTypeKey]: import_zod28.z.literal(TextAreaPropControllerDataV1Type),
+  value: import_zod28.z.string()
 });
-var textAreaPropControllerDataSchema = import_zod27.z.union([
+var textAreaPropControllerDataSchema = import_zod28.z.union([
   textAreaPropControllerDataV0Schema,
   textAreaPropControllerDataV1Schema
 ]);
@@ -2049,13 +2170,13 @@ function TextArea(options = {}) {
   return { type: Types.TextArea, version: 1, options };
 }
 function getTextAreaPropControllerDataString(data) {
-  return (0, import_ts_pattern24.match)(data).with(
+  return (0, import_ts_pattern25.match)(data).with(
     { [ControlDataTypeKey]: TextAreaPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTextAreaPropControllerDataFromString(value, definition) {
-  return (0, import_ts_pattern24.match)(definition).with(
+  return (0, import_ts_pattern25.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: TextAreaPropControllerDataV1Type,
@@ -2064,16 +2185,48 @@ function createTextAreaPropControllerDataFromString(value, definition) {
   ).otherwise(() => value);
 }
 
+// src/text-input/text-input.ts
+var import_zod29 = require("zod");
+var import_ts_pattern26 = require("ts-pattern");
+var textInputPropControllerDataV0Schema = import_zod29.z.string();
+var TextInputPropControllerDataV1Type = "prop-controllers::text-input::v1";
+var textInputPropControllerDataV1Schema = import_zod29.z.object({
+  [ControlDataTypeKey]: import_zod29.z.literal(TextInputPropControllerDataV1Type),
+  value: import_zod29.z.string()
+});
+var textInputPropControllerDataSchema = import_zod29.z.union([
+  textInputPropControllerDataV0Schema,
+  textInputPropControllerDataV1Schema
+]);
+function TextInput(options = {}) {
+  return { type: Types.TextInput, version: 1, options };
+}
+function getTextInputPropControllerDataString(data) {
+  return (0, import_ts_pattern26.match)(data).with(
+    { [ControlDataTypeKey]: TextInputPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTextInputPropControllerDataFromString(value, definition) {
+  return (0, import_ts_pattern26.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: TextInputPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
 // src/width/width.ts
-var import_ts_pattern25 = require("ts-pattern");
-var import_zod28 = require("zod");
+var import_ts_pattern27 = require("ts-pattern");
+var import_zod30 = require("zod");
 var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
-var widthPropControllerDataV1Schema = import_zod28.z.object({
-  [ControlDataTypeKey]: import_zod28.z.literal(WidthPropControllerDataV1Type),
+var widthPropControllerDataV1Schema = import_zod30.z.object({
+  [ControlDataTypeKey]: import_zod30.z.literal(WidthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var widthPropControllerDataSchema = import_zod28.z.union([
+var widthPropControllerDataSchema = import_zod30.z.union([
   widthPropControllerDataV0Schema,
   widthPropControllerDataV1Schema
 ]);
@@ -2086,15 +2239,15 @@ function Width(options = {}) {
 }
 Width.Format = WidthPropControllerFormat;
 function getWidthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern25.match)(data).with(
+  return (0, import_ts_pattern27.match)(data).with(
     { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
-  return (0, import_ts_pattern25.match)(definition).with(
+  return (0, import_ts_pattern27.match)(definition).with(
     { version: 1 },
-    import_ts_pattern25.P.nullish,
+    import_ts_pattern27.P.nullish,
     () => ({
       [ControlDataTypeKey]: WidthPropControllerDataV1Type,
       value: responsiveLengthData
@@ -2103,22 +2256,22 @@ function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthD
 }
 
 // src/video/video.ts
-var import_zod29 = require("zod");
-var import_ts_pattern26 = require("ts-pattern");
-var videoDataSchema = import_zod29.z.object({
-  url: import_zod29.z.string().optional(),
-  muted: import_zod29.z.boolean().optional(),
-  playing: import_zod29.z.boolean().optional(),
-  loop: import_zod29.z.boolean().optional(),
-  controls: import_zod29.z.boolean().optional()
+var import_zod31 = require("zod");
+var import_ts_pattern28 = require("ts-pattern");
+var videoDataSchema = import_zod31.z.object({
+  url: import_zod31.z.string().optional(),
+  muted: import_zod31.z.boolean().optional(),
+  playing: import_zod31.z.boolean().optional(),
+  loop: import_zod31.z.boolean().optional(),
+  controls: import_zod31.z.boolean().optional()
 });
 var videoPropControllerDataV0Schema = videoDataSchema;
 var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
-var videoPropControllerDataV1Schema = import_zod29.z.object({
-  [ControlDataTypeKey]: import_zod29.z.literal(VideoPropControllerDataV1Type),
+var videoPropControllerDataV1Schema = import_zod31.z.object({
+  [ControlDataTypeKey]: import_zod31.z.literal(VideoPropControllerDataV1Type),
   value: videoDataSchema
 });
-var videoPropControllerDataSchema = import_zod29.z.union([
+var videoPropControllerDataSchema = import_zod31.z.union([
   videoPropControllerDataV1Schema,
   videoPropControllerDataV0Schema
 ]);
@@ -2126,15 +2279,15 @@ function Video(options = {}) {
   return { type: Types.Video, version: 1, options };
 }
 function getVideoPropControllerDataVideoData(data) {
-  return (0, import_ts_pattern26.match)(data).with(
+  return (0, import_ts_pattern28.match)(data).with(
     { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createVideoPropControllerDataFromVideoData(value, definition) {
-  return (0, import_ts_pattern26.match)(definition).with(
+  return (0, import_ts_pattern28.match)(definition).with(
     { version: 1 },
-    import_ts_pattern26.P.nullish,
+    import_ts_pattern28.P.nullish,
     () => ({
       [ControlDataTypeKey]: VideoPropControllerDataV1Type,
       value
@@ -2172,10 +2325,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   ResponsiveLengthPropControllerDataV1Type,
   ResponsiveNumber,
   ResponsiveOpacity,
+  ResponsiveSelect,
   Shadows,
+  SocialLinks,
   Table,
   TableFormFields,
   TextArea,
+  TextInput,
   TextStyle,
   Types,
   Video,
@@ -2219,9 +2375,11 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createResponsiveLengthPropControllerDataFromResponsiveLengthData,
   createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData,
+  createSocialLinksPropControllerDataFromSocialLinksData,
   createTableFormFieldsPropControllerDataFromTableFormFieldsData,
   createTablePropControllerDataFromTableId,
   createTextAreaPropControllerDataFromString,
+  createTextInputPropControllerDataFromString,
   createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData,
@@ -2265,10 +2423,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getResponsiveLengthPropControllerDataResponsiveLengthData,
   getShadowsPropControllerDataResponsiveShadowsData,
   getShadowsPropControllerDataSwatchIds,
+  getSocialLinkTypes,
+  getSocialLinksPropControllerDataSocialLinksData,
   getTableFormFieldsPropControllerDataTableFormFieldsData,
   getTablePropControllerDataTableId,
   getTablePropControllerDataTableIds,
   getTextAreaPropControllerDataString,
+  getTextInputPropControllerDataString,
   getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData,
@@ -2292,11 +2453,15 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   responsiveLengthPropControllerDataSchema,
   responsiveNumberValueSchema,
   responsiveOpacityValueSchema,
+  responsiveSelectValueSchema,
   shadowsPropControllerDataSchema,
+  socialLinksPropControllerDataSchema,
   tableFormFieldsPropControllerDataSchema,
   tablePropControllerDataSchema,
   textAreaPropControllerDataSchema,
+  textInputPropControllerDataSchema,
   textStylePropControllerDataSchema,
+  typeArg,
   versionedPropDef,
   videoPropControllerDataSchema,
   widthPropControllerDataSchema