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

package/dist/index.cjs

@@ -29,9 +29,9 @@ __export(src_exports, {
   Date: () => Date,
   Font: () => Font,
   Link: () => Link,
-  LinkPropControllerDataV1Type: () => LinkPropControllerDataV1Type,
   Margin: () => Margin,
   MarginPropControllerFormat: () => MarginPropControllerFormat,
+  NavigationLinks: () => NavigationLinks,
   Number: () => Number,
   Padding: () => Padding,
   PaddingPropControllerFormat: () => PaddingPropControllerFormat,
@@ -50,6 +50,7 @@ __export(src_exports, {
   checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
   copyBorderPropControllerData: () => copyBorderPropControllerData,
   copyLinkPropControllerData: () => copyLinkPropControllerData,
+  copyNavigationLinksPropControllerData: () => copyNavigationLinksPropControllerData,
   copyResponsiveColorPropControllerData: () => copyResponsiveColorPropControllerData,
   copyShadowsPropControllerData: () => copyShadowsPropControllerData,
   copyTablePropControllerData: () => copyTablePropControllerData,
@@ -58,7 +59,9 @@ __export(src_exports, {
   createCheckboxPropControllerDataFromBoolean: () => createCheckboxPropControllerDataFromBoolean,
   createDatePropControllerDataFromString: () => createDatePropControllerDataFromString,
   createFontPropControllerDataFromResponsiveFontData: () => createFontPropControllerDataFromResponsiveFontData,
+  createLinkPropControllerDataFromLinkData: () => createLinkPropControllerDataFromLinkData,
   createMarginPropControllerDataFromResponsiveMarginData: () => createMarginPropControllerDataFromResponsiveMarginData,
+  createNavigationLinksPropControllerDataFromNavigationLinksData: () => createNavigationLinksPropControllerDataFromNavigationLinksData,
   createNumberPropControllerDataFromNumber: () => createNumberPropControllerDataFromNumber,
   createPaddingPropControllerDataFromResponsivePaddingData: () => createPaddingPropControllerDataFromResponsivePaddingData,
   createResponsiveColorPropControllerDataFromResponsiveColorData: () => createResponsiveColorPropControllerDataFromResponsiveColorData,
@@ -77,9 +80,12 @@ __export(src_exports, {
   getCheckboxPropControllerDataBoolean: () => getCheckboxPropControllerDataBoolean,
   getDatePropControllerDataString: () => getDatePropControllerDataString,
   getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
+  getLinkPropControllerDataLinkData: () => getLinkPropControllerDataLinkData,
   getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
-  getLinkPropControllerValue: () => getLinkPropControllerValue,
   getMarginPropControllerDataResponsiveMarginData: () => getMarginPropControllerDataResponsiveMarginData,
+  getNavigationLinksPropControllerDataNavigationLinksData: () => getNavigationLinksPropControllerDataNavigationLinksData,
+  getNavigationLinksPropControllerPageIds: () => getNavigationLinksPropControllerPageIds,
+  getNavigationLinksPropControllerSwatchIds: () => getNavigationLinksPropControllerSwatchIds,
   getNumberPropControllerDataNumber: () => getNumberPropControllerDataNumber,
   getPaddingPropControllerDataResponsivePaddingData: () => getPaddingPropControllerDataResponsivePaddingData,
   getResponsiveColorDataSwatchIds: () => getResponsiveColorDataSwatchIds,
@@ -93,7 +99,10 @@ __export(src_exports, {
   getTextStylePropControllerDataResponsiveTextStyleData: () => getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
+  linkDataSchema: () => linkDataSchema,
+  linkPropControllerDataSchema: () => linkPropControllerDataSchema,
   marginPropControllerDataSchema: () => marginPropControllerDataSchema,
+  navigationLinksPropControllerDataSchema: () => navigationLinksPropControllerDataSchema,
   numberPropControllerDataSchema: () => numberPropControllerDataSchema,
   paddingPropControllerDataSchema: () => paddingPropControllerDataSchema,
   responsiveColorPropControllerDataSchema: () => responsiveColorPropControllerDataSchema,
@@ -106,22 +115,8 @@ __export(src_exports, {
 });
 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 import_zod = require("zod");
 var Types = {
   Border: "Border",
   BorderRadius: "BorderRadius",
@@ -130,6 +125,7 @@ var Types = {
   Font: "Font",
   Link: "Link",
   Margin: "Margin",
+  NavigationLinks: "NavigationLinks",
   Padding: "Padding",
   Number: "Number",
   Shadows: "Shadows",
@@ -141,17 +137,31 @@ var Types = {
   Video: "Video"
 };
 var ControlDataTypeKey = "@@makeswift/type";
-var deviceSchema = import_zod2.z.string();
+var deviceSchema = import_zod.z.string();
 function createDeviceOverrideSchema(schema) {
-  return import_zod2.z.object({
+  return import_zod.z.object({
     deviceId: deviceSchema,
     value: schema
   });
 }
 function createResponsiveValueSchema(schema) {
-  return import_zod2.z.array(createDeviceOverrideSchema(schema));
+  return import_zod.z.array(createDeviceOverrideSchema(schema));
 }
 
+// src/border/border.ts
+var import_ts_pattern = require("ts-pattern");
+
+// src/data.ts
+var import_zod2 = require("zod");
+var colorDataSchema = import_zod2.z.object({
+  swatchId: import_zod2.z.string(),
+  alpha: import_zod2.z.number()
+});
+var lengthDataSchema = import_zod2.z.object({
+  value: import_zod2.z.number(),
+  unit: import_zod2.z.union([import_zod2.z.literal("px"), import_zod2.z.literal("%")])
+});
+
 // src/border/border.ts
 var import_zod3 = require("zod");
 var borderSideDataSchema = import_zod3.z.object({
@@ -409,17 +419,94 @@ function createFontPropControllerDataFromResponsiveFontData(responsiveFontData,
 
 // src/link/link.ts
 var import_ts_pattern6 = require("ts-pattern");
+var import_zod8 = require("zod");
+var openPageLinkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("OPEN_PAGE"),
+  payload: import_zod8.z.object({
+    pageId: import_zod8.z.string().nullable().optional(),
+    openInNewTab: import_zod8.z.boolean()
+  }).transform((v) => ({
+    pageId: v.pageId,
+    ...v
+  }))
+});
+var openURLLinkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("OPEN_URL"),
+  payload: import_zod8.z.object({
+    url: import_zod8.z.string(),
+    openInNewTab: import_zod8.z.boolean()
+  })
+});
+var sendEmailLinkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("SEND_EMAIL"),
+  payload: import_zod8.z.object({
+    to: import_zod8.z.string(),
+    subject: import_zod8.z.string().optional(),
+    body: import_zod8.z.string().optional()
+  })
+});
+var callPhoneLinkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("CALL_PHONE"),
+  payload: import_zod8.z.object({
+    phoneNumber: import_zod8.z.string()
+  })
+});
+var scrollToElementLinkSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("SCROLL_TO_ELEMENT"),
+  payload: import_zod8.z.object({
+    elementIdConfig: import_zod8.z.object({
+      elementKey: import_zod8.z.string(),
+      propName: import_zod8.z.string()
+    }).nullable().optional(),
+    block: import_zod8.z.union([
+      import_zod8.z.literal("start"),
+      import_zod8.z.literal("center"),
+      import_zod8.z.literal("end")
+    ])
+  }).transform((v) => ({
+    elementIdConfig: v.elementIdConfig,
+    ...v
+  }))
+});
+var linkDataSchema = import_zod8.z.union([
+  openPageLinkSchema,
+  openURLLinkSchema,
+  sendEmailLinkSchema,
+  callPhoneLinkSchema,
+  scrollToElementLinkSchema
+]);
+var linkPropControllerDataV0Schema = linkDataSchema;
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
-function getLinkPropControllerValue(data) {
+var linkPropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(LinkPropControllerDataV1Type),
+  value: linkDataSchema
+});
+var linkPropControllerDataSchema = import_zod8.z.union([
+  linkPropControllerDataV0Schema,
+  linkPropControllerDataV1Schema
+]);
+function Link(options = {}) {
+  return { type: Types.Link, version: 1, options };
+}
+function getLinkPropControllerDataLinkData(data) {
   return (0, import_ts_pattern6.match)(data).with(
     { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
+function createLinkPropControllerDataFromLinkData(value, definition) {
+  return (0, import_ts_pattern6.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: LinkPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
 function getLinkPropControllerPageIds(linkData) {
   if (linkData == null)
     return [];
-  const link = getLinkPropControllerValue(linkData);
+  const link = getLinkPropControllerDataLinkData(linkData);
   switch (link.type) {
     case "OPEN_PAGE":
       return link.payload.pageId == null ? [] : [link.payload.pageId];
@@ -427,10 +514,8 @@ function getLinkPropControllerPageIds(linkData) {
       return [];
   }
 }
-function copyLinkPropControllerData(data, context) {
-  if (data == null)
-    return data;
-  let value = getLinkPropControllerValue(data);
+function copyLinkData(data, context) {
+  let value = data;
   switch (value?.type) {
     case "OPEN_PAGE":
       {
@@ -465,26 +550,31 @@ function copyLinkPropControllerData(data, context) {
       break;
     }
   }
+  return value;
+}
+function copyLinkPropControllerData(data, context) {
+  if (data == null)
+    return data;
+  const value = copyLinkData(getLinkPropControllerDataLinkData(data), context);
+  if (value == null)
+    return value;
   return (0, import_ts_pattern6.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
     ...v1,
     value
   })).otherwise((_) => value);
 }
-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")
+var import_zod9 = require("zod");
+var marginSideDataSchema = import_zod9.z.union([
+  import_zod9.z.object({
+    value: import_zod9.z.number(),
+    unit: import_zod9.z.literal("px")
   }),
-  import_zod8.z.literal("auto")
+  import_zod9.z.literal("auto")
 ]);
-var marginDataSchema = import_zod8.z.object({
+var marginDataSchema = import_zod9.z.object({
   marginTop: marginSideDataSchema.nullable().optional(),
   marginRight: marginSideDataSchema.nullable().optional(),
   marginBottom: marginSideDataSchema.nullable().optional(),
@@ -498,11 +588,11 @@ var marginDataSchema = import_zod8.z.object({
 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),
+var marginPropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(MarginPropControllerDataV1Type),
   value: responsiveMarginDataSchema
 });
-var marginPropControllerDataSchema = import_zod8.z.union([
+var marginPropControllerDataSchema = import_zod9.z.union([
   marginPropControllerDataV0Schema,
   marginPropControllerDataV1Schema
 ]);
@@ -531,96 +621,64 @@ function createMarginPropControllerDataFromResponsiveMarginData(responsiveMargin
   ).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/navigation-links/navigation-links.ts
+var import_ts_pattern10 = require("ts-pattern");
+var import_zod12 = require("zod");
 
-// src/padding/padding.ts
-var import_ts_pattern9 = require("ts-pattern");
+// src/text-style/text-style.ts
+var import_ts_pattern8 = 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()
+var textStyleDataSchema = import_zod10.z.object({
+  fontFamily: import_zod10.z.string().optional().nullable(),
+  letterSpacing: import_zod10.z.number().optional().nullable(),
+  fontSize: import_zod10.z.object({
+    value: import_zod10.z.number(),
+    unit: import_zod10.z.literal("px")
+  }).optional().nullable(),
+  fontWeight: import_zod10.z.number().optional().nullable(),
+  textTransform: import_zod10.z.array(import_zod10.z.literal("uppercase")),
+  fontStyle: import_zod10.z.array(import_zod10.z.literal("italic"))
 }).transform((v) => ({
-  paddingTop: v.paddingTop,
-  paddingRight: v.paddingRight,
-  paddingBottom: v.paddingBottom,
-  paddingLeft: v.paddingLeft
+  ...v,
+  letterSpacing: v.letterSpacing,
+  fontSize: v.fontSize,
+  fontWeight: v.fontWeight,
+  textTransform: v.textTransform,
+  fontStyle: v.fontStyle
 }));
-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 responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
+var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
+var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
+var textStylePropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(TextStylePropControllerDataV1Type),
+  value: responsiveTextStyleDataSchema
 });
-var paddingPropControllerDataSchema = import_zod10.z.union([
-  paddingPropControllerDataV0Schema,
-  paddingPropControllerDataV1Schema
+var textStylePropControllerDataSchema = import_zod10.z.union([
+  textStylePropControllerDataV0Schema,
+  textStylePropControllerDataV1Schema
 ]);
-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 };
+function TextStyle(options = {}) {
+  return { type: Types.TextStyle, version: 1, options };
 }
-Padding.Format = PaddingPropControllerFormat;
-function getPaddingPropControllerDataResponsivePaddingData(data) {
-  return (0, import_ts_pattern9.match)(data).with(
-    { [ControlDataTypeKey]: PaddingPropControllerDataV1Type },
+function getTextStylePropControllerDataResponsiveTextStyleData(data) {
+  return (0, import_ts_pattern8.match)(data).with(
+    { [ControlDataTypeKey]: TextStylePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
-function createPaddingPropControllerDataFromResponsivePaddingData(responsivePaddingData, definition) {
-  return (0, import_ts_pattern9.match)(definition).with(
+function createTextStylePropControllerDataFromResponsiveTextStyleData(responsiveTextStyleData, definition) {
+  return (0, import_ts_pattern8.match)(definition).with(
     { version: 1 },
-    import_ts_pattern9.P.nullish,
     () => ({
-      [ControlDataTypeKey]: PaddingPropControllerDataV1Type,
-      value: responsivePaddingData
+      [ControlDataTypeKey]: TextStylePropControllerDataV1Type,
+      value: responsiveTextStyleData
     })
-  ).otherwise(() => responsivePaddingData);
+  ).otherwise(() => responsiveTextStyleData);
 }
 
 // src/responsive-color.ts
 var import_zod11 = require("zod");
-var import_ts_pattern10 = require("ts-pattern");
+var import_ts_pattern9 = require("ts-pattern");
 var responsiveColorDataSchema = createResponsiveValueSchema(colorDataSchema);
 var responsiveColorPropControllerDataV0Schema = responsiveColorDataSchema;
 var ResponsiveColorPropControllerDataV1Type = "prop-controllers::responsive-color::v1";
@@ -636,13 +694,13 @@ function ResponsiveColor(options = {}) {
   return { type: Types.ResponsiveColor, version: 1, options };
 }
 function getResponsiveColorPropControllerDataResponsiveColorData(data) {
-  return (0, import_ts_pattern10.match)(data).with(
+  return (0, import_ts_pattern9.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
-  return (0, import_ts_pattern10.match)(definition).with(
+  return (0, import_ts_pattern9.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -673,7 +731,7 @@ function copyResponsiveColorData(data, context) {
   }
 }
 function copyResponsiveColorPropControllerData(data, context) {
-  return (0, import_ts_pattern10.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern9.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -682,17 +740,283 @@ function copyResponsiveColorPropControllerData(data, context) {
   ).otherwise((v0) => copyResponsiveColorData(v0, context));
 }
 
-// src/responsive-length.ts
-var import_zod12 = require("zod");
+// src/navigation-links/navigation-links.ts
+var buttonVariantSchema = import_zod12.z.enum([
+  "flat",
+  "outline",
+  "shadow",
+  "clear",
+  "blocky",
+  "bubbly",
+  "skewed"
+]);
+var buttonShapeSchema = import_zod12.z.enum(["pill", "rounded", "square"]);
+var buttonSizeSchema = import_zod12.z.enum(["small", "medium", "large"]);
+var navigationButtonSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  type: import_zod12.z.literal("button"),
+  payload: import_zod12.z.object({
+    label: import_zod12.z.string(),
+    link: linkDataSchema.optional(),
+    variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
+    shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
+    size: createResponsiveValueSchema(buttonSizeSchema).optional(),
+    textColor: createResponsiveValueSchema(colorDataSchema).optional(),
+    color: createResponsiveValueSchema(colorDataSchema).optional(),
+    textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
+  })
+});
+var navigationDropdownCaretTypeSchema = import_zod12.z.union([
+  import_zod12.z.literal("caret"),
+  import_zod12.z.literal("plus"),
+  import_zod12.z.literal("arrow-down"),
+  import_zod12.z.literal("chevron-down")
+]);
+var navigationDropdownLinkSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  payload: import_zod12.z.object({
+    label: import_zod12.z.string(),
+    link: linkDataSchema.optional(),
+    color: createResponsiveValueSchema(colorDataSchema).optional(),
+    textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
+  })
+});
+var navigationDropdownSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  type: import_zod12.z.literal("dropdown"),
+  payload: import_zod12.z.object({
+    label: import_zod12.z.string(),
+    caret: navigationDropdownCaretTypeSchema.optional(),
+    links: import_zod12.z.array(navigationDropdownLinkSchema).optional(),
+    variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
+    shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
+    size: createResponsiveValueSchema(buttonSizeSchema).optional(),
+    textColor: createResponsiveValueSchema(colorDataSchema).optional(),
+    color: createResponsiveValueSchema(colorDataSchema).optional(),
+    textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
+  })
+});
+var navigationLinksDataSchema = import_zod12.z.array(
+  import_zod12.z.union([navigationButtonSchema, navigationDropdownSchema])
+);
+var navigationLinksPropControllerDataV0Schema = navigationLinksDataSchema;
+var NavigationLinksPropControllerDataV1Type = "prop-controllers::navigation-links::v1";
+var navigationLinksPropControllerDataV1Schema = import_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(NavigationLinksPropControllerDataV1Type),
+  value: navigationLinksDataSchema
+});
+var navigationLinksPropControllerDataSchema = import_zod12.z.union([
+  navigationLinksPropControllerDataV0Schema,
+  navigationLinksPropControllerDataV1Schema
+]);
+function NavigationLinks(options = {}) {
+  return { type: Types.NavigationLinks, version: 1, options };
+}
+function getNavigationLinksPropControllerDataNavigationLinksData(data) {
+  return (0, import_ts_pattern10.match)(data).with(
+    { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createNavigationLinksPropControllerDataFromNavigationLinksData(navigationLinksData, definition) {
+  return (0, import_ts_pattern10.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
+      value: navigationLinksData
+    })
+  ).otherwise(() => navigationLinksData);
+}
+function getNavigationLinksPropControllerPageIds(data) {
+  if (data == null)
+    return [];
+  const value = getNavigationLinksPropControllerDataNavigationLinksData(data);
+  return value?.flatMap((item) => {
+    switch (item.type) {
+      case "button": {
+        if (item.payload.link == null)
+          return [];
+        switch (item.payload.link.type) {
+          case "OPEN_PAGE":
+            return item.payload.link.payload.pageId == null ? [] : [item.payload.link.payload.pageId];
+          default:
+            return [];
+        }
+      }
+      case "dropdown": {
+        return item.payload.links?.flatMap((link) => {
+          if (link.payload.link == null)
+            return [];
+          switch (link.payload.link.type) {
+            case "OPEN_PAGE":
+              return link.payload.link.payload.pageId == null ? [] : [link.payload.link.payload.pageId];
+            default:
+              return [];
+          }
+        }) ?? [];
+      }
+    }
+  }) ?? [];
+}
+function getNavigationLinksPropControllerSwatchIds(data) {
+  if (data == null)
+    return [];
+  const value = getNavigationLinksPropControllerDataNavigationLinksData(data);
+  return value?.flatMap((item) => {
+    switch (item.type) {
+      case "button":
+      case "dropdown":
+        return [
+          ...item.payload.color?.map((override) => override.value).map((color) => color.swatchId) ?? [],
+          ...item.payload.textColor?.map((override) => override.value).map((color) => color.swatchId) ?? []
+        ];
+    }
+  }) ?? [];
+}
+function copyNavigationLinksData(data, context) {
+  return data?.map((item) => {
+    switch (item.type) {
+      case "button": {
+        const { color, link } = item.payload;
+        return {
+          ...item,
+          payload: {
+            ...item.payload,
+            link: copyLinkData(link, context),
+            color: color != null ? copyResponsiveColorData(color, context) : void 0
+          }
+        };
+      }
+      case "dropdown": {
+        const { color, links } = item.payload;
+        return {
+          ...item,
+          payload: {
+            ...item.payload,
+            links: links != null ? links.map((link) => ({
+              ...link,
+              payload: {
+                ...link.payload,
+                link: copyLinkData(link.payload.link, context)
+              }
+            })) : void 0,
+            color: color != null ? copyResponsiveColorData(color, context) : void 0
+          }
+        };
+      }
+      default:
+        return item;
+    }
+  });
+}
+function copyNavigationLinksPropControllerData(data, context) {
+  return (0, import_ts_pattern10.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
+      value: copyNavigationLinksData(v1.value, context)
+    })
+  ).otherwise((v0) => copyNavigationLinksData(v0, context));
+}
+
+// src/number.ts
+var import_zod13 = require("zod");
 var import_ts_pattern11 = require("ts-pattern");
+var numberPropControllerDataV0Schema = import_zod13.z.number();
+var NumberPropControllerDataV1Type = "prop-controllers::number::v1";
+var numberPropControllerDataV1Schema = import_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod13.z.number()
+});
+var numberPropControllerDataSchema = import_zod13.z.union([
+  numberPropControllerDataV0Schema,
+  numberPropControllerDataV1Schema
+]);
+function Number(options = {}) {
+  return { type: Types.Number, version: 1, options };
+}
+function getNumberPropControllerDataNumber(data) {
+  return (0, import_ts_pattern11.match)(data).with(
+    { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createNumberPropControllerDataFromNumber(value, definition) {
+  return (0, import_ts_pattern11.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern11.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: NumberPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/padding/padding.ts
+var import_ts_pattern12 = require("ts-pattern");
+var import_zod14 = require("zod");
+var paddingSideDataSchema = import_zod14.z.object({
+  value: import_zod14.z.number(),
+  unit: import_zod14.z.literal("px")
+});
+var paddingDataSchema = import_zod14.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_zod14.z.object({
+  [ControlDataTypeKey]: import_zod14.z.literal(PaddingPropControllerDataV1Type),
+  value: responsivePaddingDataSchema
+});
+var paddingPropControllerDataSchema = import_zod14.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_pattern12.match)(data).with(
+    { [ControlDataTypeKey]: PaddingPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createPaddingPropControllerDataFromResponsivePaddingData(responsivePaddingData, definition) {
+  return (0, import_ts_pattern12.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern12.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: PaddingPropControllerDataV1Type,
+      value: responsivePaddingData
+    })
+  ).otherwise(() => responsivePaddingData);
+}
+
+// src/responsive-length.ts
+var import_zod15 = require("zod");
+var import_ts_pattern13 = 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),
+var responsiveLengthPropControllerDataV1Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(ResponsiveLengthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var responsiveLengthPropControllerDataSchema = import_zod12.z.union([
+var responsiveLengthPropControllerDataSchema = import_zod15.z.union([
   responsiveLengthPropControllerDataV0Schema,
   responsiveLengthPropControllerDataV1Schema
 ]);
@@ -700,13 +1024,13 @@ function ResponsiveLength(options = {}) {
   return { type: Types.ResponsiveLength, version: 1, options };
 }
 function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern11.match)(data).with(
+  return (0, import_ts_pattern13.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
-  return (0, import_ts_pattern11.match)(definition).with(
+  return (0, import_ts_pattern13.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
@@ -716,30 +1040,30 @@ function createResponsiveLengthPropControllerDataFromResponsiveLengthData(defini
 }
 
 // src/shadows.ts
-var import_ts_pattern12 = require("ts-pattern");
-var import_zod13 = require("zod");
-var shadowDataSchema = import_zod13.z.object({
+var import_ts_pattern14 = require("ts-pattern");
+var import_zod16 = require("zod");
+var shadowDataSchema = import_zod16.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()
+  blurRadius: import_zod16.z.number().optional(),
+  spreadRadius: import_zod16.z.number().optional(),
+  offsetX: import_zod16.z.number().optional(),
+  offsetY: import_zod16.z.number().optional(),
+  inset: import_zod16.z.boolean().optional()
 });
-var shadowsDataSchema = import_zod13.z.array(
-  import_zod13.z.object({
-    id: import_zod13.z.string(),
+var shadowsDataSchema = import_zod16.z.array(
+  import_zod16.z.object({
+    id: import_zod16.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),
+var shadowsPropControllerDataV1Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(ShadowsPropControllerDataV1Type),
   value: responsiveShadowsDataSchema
 });
-var shadowsPropControllerDataSchema = import_zod13.z.union([
+var shadowsPropControllerDataSchema = import_zod16.z.union([
   shadowsPropControllerDataV0Schema,
   shadowsPropControllerDataV1Schema
 ]);
@@ -752,13 +1076,13 @@ function Shadows(options = {}) {
 }
 Shadows.Format = ShadowsPropControllerFormat;
 function getShadowsPropControllerDataResponsiveShadowsData(data) {
-  return (0, import_ts_pattern12.match)(data).with(
+  return (0, import_ts_pattern14.match)(data).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
-  return (0, import_ts_pattern12.match)(definition).with(
+  return (0, import_ts_pattern14.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -792,7 +1116,7 @@ function copyResponsiveShadowsData(data, context) {
   }));
 }
 function copyShadowsPropControllerData(data, context) {
-  return (0, import_ts_pattern12.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern14.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -802,16 +1126,16 @@ function copyShadowsPropControllerData(data, context) {
 }
 
 // src/table/table.ts
-var import_zod14 = require("zod");
-var import_ts_pattern13 = require("ts-pattern");
-var tableIdSchema = import_zod14.z.string();
+var import_zod17 = require("zod");
+var import_ts_pattern15 = require("ts-pattern");
+var tableIdSchema = import_zod17.z.string();
 var tablePropControllerDataV0Schema = tableIdSchema;
 var TablePropControllerDataV1Type = "prop-controllers::table::v1";
-var tablePropControllerDataV1Schema = import_zod14.z.object({
-  [ControlDataTypeKey]: import_zod14.z.literal(TablePropControllerDataV1Type),
+var tablePropControllerDataV1Schema = import_zod17.z.object({
+  [ControlDataTypeKey]: import_zod17.z.literal(TablePropControllerDataV1Type),
   value: tableIdSchema
 });
-var tablePropControllerDataSchema = import_zod14.z.union([
+var tablePropControllerDataSchema = import_zod17.z.union([
   tablePropControllerDataV0Schema,
   tablePropControllerDataV1Schema
 ]);
@@ -819,15 +1143,15 @@ function Table(options = {}) {
   return { type: Types.Table, version: 1, options };
 }
 function getTablePropControllerDataTableId(data) {
-  return (0, import_ts_pattern13.match)(data).with(
+  return (0, import_ts_pattern15.match)(data).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTablePropControllerDataFromTableId(value, definition) {
-  return (0, import_ts_pattern13.match)(definition).with(
+  return (0, import_ts_pattern15.match)(definition).with(
     { version: 1 },
-    import_ts_pattern13.P.nullish,
+    import_ts_pattern15.P.nullish,
     () => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
       value
@@ -840,7 +1164,7 @@ function copyTableId(data, context) {
   return context.replacementContext.tableIds.get(data) ?? data;
 }
 function copyTablePropControllerData(data, context) {
-  return (0, import_ts_pattern13.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern15.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
@@ -853,67 +1177,16 @@ function getTablePropControllerDataTableIds(data) {
   return value ? [value] : [];
 }
 
-// src/text-style/text-style.ts
-var import_ts_pattern14 = require("ts-pattern");
-var import_zod15 = require("zod");
-var textStyleDataSchema = import_zod15.z.object({
-  fontFamily: import_zod15.z.string().optional().nullable(),
-  letterSpacing: import_zod15.z.number().optional().nullable(),
-  fontSize: import_zod15.z.object({
-    value: import_zod15.z.number(),
-    unit: import_zod15.z.literal("px")
-  }).optional().nullable(),
-  fontWeight: import_zod15.z.number().optional().nullable(),
-  textTransform: import_zod15.z.array(import_zod15.z.literal("uppercase")),
-  fontStyle: import_zod15.z.array(import_zod15.z.literal("italic"))
-}).transform((v) => ({
-  ...v,
-  letterSpacing: v.letterSpacing,
-  fontSize: v.fontSize,
-  fontWeight: v.fontWeight,
-  textTransform: v.textTransform,
-  fontStyle: v.fontStyle
-}));
-var responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
-var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
-var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
-var textStylePropControllerDataV1Schema = import_zod15.z.object({
-  [ControlDataTypeKey]: import_zod15.z.literal(TextStylePropControllerDataV1Type),
-  value: responsiveTextStyleDataSchema
-});
-var textStylePropControllerDataSchema = import_zod15.z.union([
-  textStylePropControllerDataV0Schema,
-  textStylePropControllerDataV1Schema
-]);
-function TextStyle(options = {}) {
-  return { type: Types.TextStyle, version: 1, options };
-}
-function getTextStylePropControllerDataResponsiveTextStyleData(data) {
-  return (0, import_ts_pattern14.match)(data).with(
-    { [ControlDataTypeKey]: TextStylePropControllerDataV1Type },
-    (v1) => v1.value
-  ).otherwise((v0) => v0);
-}
-function createTextStylePropControllerDataFromResponsiveTextStyleData(responsiveTextStyleData, definition) {
-  return (0, import_ts_pattern14.match)(definition).with(
-    { version: 1 },
-    () => ({
-      [ControlDataTypeKey]: TextStylePropControllerDataV1Type,
-      value: responsiveTextStyleData
-    })
-  ).otherwise(() => responsiveTextStyleData);
-}
-
 // src/width/width.ts
-var import_ts_pattern15 = require("ts-pattern");
-var import_zod16 = require("zod");
+var import_ts_pattern16 = require("ts-pattern");
+var import_zod18 = require("zod");
 var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
-var widthPropControllerDataV1Schema = import_zod16.z.object({
-  [ControlDataTypeKey]: import_zod16.z.literal(WidthPropControllerDataV1Type),
+var widthPropControllerDataV1Schema = import_zod18.z.object({
+  [ControlDataTypeKey]: import_zod18.z.literal(WidthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var widthPropControllerDataSchema = import_zod16.z.union([
+var widthPropControllerDataSchema = import_zod18.z.union([
   widthPropControllerDataV0Schema,
   widthPropControllerDataV1Schema
 ]);
@@ -926,15 +1199,15 @@ function Width(options = {}) {
 }
 Width.Format = WidthPropControllerFormat;
 function getWidthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern15.match)(data).with(
+  return (0, import_ts_pattern16.match)(data).with(
     { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
-  return (0, import_ts_pattern15.match)(definition).with(
+  return (0, import_ts_pattern16.match)(definition).with(
     { version: 1 },
-    import_ts_pattern15.P.nullish,
+    import_ts_pattern16.P.nullish,
     () => ({
       [ControlDataTypeKey]: WidthPropControllerDataV1Type,
       value: responsiveLengthData
@@ -943,22 +1216,22 @@ function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthD
 }
 
 // src/video/video.ts
-var import_zod17 = require("zod");
-var import_ts_pattern16 = require("ts-pattern");
-var videoDataSchema = import_zod17.z.object({
-  url: import_zod17.z.string().optional(),
-  muted: import_zod17.z.boolean().optional(),
-  playing: import_zod17.z.boolean().optional(),
-  loop: import_zod17.z.boolean().optional(),
-  controls: import_zod17.z.boolean().optional()
+var import_zod19 = require("zod");
+var import_ts_pattern17 = require("ts-pattern");
+var videoDataSchema = import_zod19.z.object({
+  url: import_zod19.z.string().optional(),
+  muted: import_zod19.z.boolean().optional(),
+  playing: import_zod19.z.boolean().optional(),
+  loop: import_zod19.z.boolean().optional(),
+  controls: import_zod19.z.boolean().optional()
 });
 var videoPropControllerDataV0Schema = videoDataSchema;
 var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
-var videoPropControllerDataV1Schema = import_zod17.z.object({
-  [ControlDataTypeKey]: import_zod17.z.literal(VideoPropControllerDataV1Type),
+var videoPropControllerDataV1Schema = import_zod19.z.object({
+  [ControlDataTypeKey]: import_zod19.z.literal(VideoPropControllerDataV1Type),
   value: videoDataSchema
 });
-var videoPropControllerDataSchema = import_zod17.z.union([
+var videoPropControllerDataSchema = import_zod19.z.union([
   videoPropControllerDataV1Schema,
   videoPropControllerDataV0Schema
 ]);
@@ -966,15 +1239,15 @@ function Video(options = {}) {
   return { type: Types.Video, version: 1, options };
 }
 function getVideoPropControllerDataVideoData(data) {
-  return (0, import_ts_pattern16.match)(data).with(
+  return (0, import_ts_pattern17.match)(data).with(
     { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createVideoPropControllerDataFromVideoData(value, definition) {
-  return (0, import_ts_pattern16.match)(definition).with(
+  return (0, import_ts_pattern17.match)(definition).with(
     { version: 1 },
-    import_ts_pattern16.P.nullish,
+    import_ts_pattern17.P.nullish,
     () => ({
       [ControlDataTypeKey]: VideoPropControllerDataV1Type,
       value
@@ -992,9 +1265,9 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   Date,
   Font,
   Link,
-  LinkPropControllerDataV1Type,
   Margin,
   MarginPropControllerFormat,
+  NavigationLinks,
   Number,
   Padding,
   PaddingPropControllerFormat,
@@ -1013,6 +1286,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   checkboxPropControllerDataSchema,
   copyBorderPropControllerData,
   copyLinkPropControllerData,
+  copyNavigationLinksPropControllerData,
   copyResponsiveColorPropControllerData,
   copyShadowsPropControllerData,
   copyTablePropControllerData,
@@ -1021,7 +1295,9 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createCheckboxPropControllerDataFromBoolean,
   createDatePropControllerDataFromString,
   createFontPropControllerDataFromResponsiveFontData,
+  createLinkPropControllerDataFromLinkData,
   createMarginPropControllerDataFromResponsiveMarginData,
+  createNavigationLinksPropControllerDataFromNavigationLinksData,
   createNumberPropControllerDataFromNumber,
   createPaddingPropControllerDataFromResponsivePaddingData,
   createResponsiveColorPropControllerDataFromResponsiveColorData,
@@ -1040,9 +1316,12 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getCheckboxPropControllerDataBoolean,
   getDatePropControllerDataString,
   getFontPropControllerDataResponsiveFontData,
+  getLinkPropControllerDataLinkData,
   getLinkPropControllerPageIds,
-  getLinkPropControllerValue,
   getMarginPropControllerDataResponsiveMarginData,
+  getNavigationLinksPropControllerDataNavigationLinksData,
+  getNavigationLinksPropControllerPageIds,
+  getNavigationLinksPropControllerSwatchIds,
   getNumberPropControllerDataNumber,
   getPaddingPropControllerDataResponsivePaddingData,
   getResponsiveColorDataSwatchIds,
@@ -1056,7 +1335,10 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData,
+  linkDataSchema,
+  linkPropControllerDataSchema,
   marginPropControllerDataSchema,
+  navigationLinksPropControllerDataSchema,
   numberPropControllerDataSchema,
   paddingPropControllerDataSchema,
   responsiveColorPropControllerDataSchema,