@applicaster/zapp-react-native-utils 16.0.0-alpha.9803580571 → 16.0.0-alpha.9953202182

package/colorUtils/__tests__/isTransparentColor.test.ts

@@ -0,0 +1,76 @@
+import { isTransparentColor } from "..";
+
+describe("isTransparentColor", () => {
+  it("returns true for transparent keyword and rgba colors with zero alpha", () => {
+    const transparentColors = [
+      "transparent",
+      "rgba(0,0,0,0)",
+      "rgba(255, 255, 255, 0)",
+      "rgba(0,0,0,0.0)",
+      "rgba(0,0,0,0.00)",
+      "rgba(0,0,0, 0)",
+      "hsla(0,0%,0%,0)",
+    ];
+
+    expect.assertions(transparentColors.length);
+
+    transparentColors.forEach((color) => {
+      expect(isTransparentColor(color)).toBe(true);
+    });
+  });
+
+  it("returns false for valid colors that are not fully transparent", () => {
+    const nonTransparentColors = [
+      "red",
+      "#fff",
+      "#ffffff",
+      "rgb(0,0,0)",
+      "rgba(0,0,0)",
+      "rgba(0,0,0,0.5)",
+      "rgba(255, 255, 255, 0.3)",
+      "rgba(255, 255, 255, 1.0)",
+      "rgba(239,239,239,1.0)",
+      "currentColor",
+      "inherit",
+      "#00000000",
+      "#fff0",
+    ];
+
+    expect.assertions(nonTransparentColors.length);
+
+    nonTransparentColors.forEach((color) => {
+      expect(isTransparentColor(color)).toBe(false);
+    });
+  });
+
+  it("returns false for case variants of the transparent keyword", () => {
+    expect(isTransparentColor("Transparent")).toBe(false);
+    expect(isTransparentColor("TRANSPARENT")).toBe(false);
+  });
+
+  it("returns false for invalid color strings", () => {
+    const invalidColors = [
+      "invalid",
+      "",
+      "#gggggg",
+      "#fff.00",
+      "unset",
+      " rgba(0,0,0,0) ",
+      "transparent ",
+    ];
+
+    expect.assertions(invalidColors.length);
+
+    invalidColors.forEach((color) => {
+      expect(isTransparentColor(color)).toBe(false);
+    });
+  });
+
+  it("returns false for nullish and non-string values", () => {
+    expect(isTransparentColor(undefined)).toBe(false);
+    expect(isTransparentColor(null)).toBe(false);
+    expect(isTransparentColor(123)).toBe(false);
+    expect(isTransparentColor({})).toBe(false);
+    expect(isTransparentColor([])).toBe(false);
+  });
+});

package/colorUtils/__tests__/isValidColor.test.ts

@@ -0,0 +1,70 @@
+import { isValidColor } from "..";
+
+describe("isValidColor", () => {
+  it("returns true for valid hex colors", () => {
+    const validHexColors = ["#fff", "#ffffff", "#FF0000", "#000", "#abc123"];
+
+    expect.assertions(validHexColors.length);
+
+    validHexColors.forEach((color) => {
+      expect(isValidColor(color)).toBe(true);
+    });
+  });
+
+  it("returns true for valid rgb and rgba colors", () => {
+    const validRgbColors = [
+      "rgb(255,0,0)",
+      "rgb(255, 0, 0)",
+      "rgba(255,0,0,0.5)",
+      "rgba(255, 0, 0, 0.5)",
+    ];
+
+    expect.assertions(validRgbColors.length);
+
+    validRgbColors.forEach((color) => {
+      expect(isValidColor(color)).toBe(true);
+    });
+  });
+
+  it("returns true for valid named and special CSS colors", () => {
+    const validNamedColors = ["red", "transparent", "currentColor", "inherit"];
+
+    expect.assertions(validNamedColors.length);
+
+    validNamedColors.forEach((color) => {
+      expect(isValidColor(color)).toBe(true);
+    });
+  });
+
+  it("returns true for valid hsl colors", () => {
+    expect(isValidColor("hsl(0, 100%, 50%)")).toBe(true);
+  });
+
+  it("returns false for invalid color strings", () => {
+    const invalidColors = [
+      "invalid",
+      "",
+      "#gggggg",
+      "#fff.00",
+      "unset",
+      undefined,
+      null,
+    ];
+
+    expect.assertions(invalidColors.length);
+
+    invalidColors.forEach((color) => {
+      expect(isValidColor(color)).toBe(false);
+    });
+  });
+
+  it("returns true for valid rgb and rgba colors", () => {
+    const validRgbColors = ["rgba(239,239,239,1.0)"];
+
+    expect.assertions(validRgbColors.length);
+
+    validRgbColors.forEach((color) => {
+      expect(isValidColor(color)).toBe(true);
+    });
+  });
+});

package/colorUtils/index.ts

@@ -0,0 +1,50 @@
+import validateColor from "validate-color";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
+import { isString } from "@applicaster/zapp-react-native-utils/stringUtils";
+
+const normalizeRgbaAlpha = (color: string): string => {
+  return color.replace(
+    /^rgba\(([^)]+),\s*(\d+(?:\.\d+)?)\s*\)$/i,
+    (_, rgb, alpha) => {
+      const alphaValue = parseFloat(alpha);
+
+      if (!Number.isFinite(alphaValue) || !Number.isInteger(alphaValue)) {
+        return color;
+      }
+
+      return `rgba(${rgb},${alphaValue})`;
+    }
+  );
+};
+
+export const isValidColor = (color: string): boolean => {
+  if (isNil(color) || !isString(color)) {
+    return false;
+  }
+
+  if (validateColor(color)) {
+    return true;
+  }
+
+  // validate-color rejects integer alpha values written as floats (e.g. 1.0)
+  // https://github.com/dreamyguy/validate-color/issues/44
+  const normalizedColor = normalizeRgbaAlpha(color);
+
+  return normalizedColor !== color && validateColor(normalizedColor);
+};
+
+function isRgbaAlphaZero(color: string): boolean {
+  const layers = color
+    .replace("rgba(", "")
+    .replace(")", "")
+    .split(",")
+    .map((layer) => layer.trim());
+
+  return Number(layers[3]) === 0;
+}
+
+export const isTransparentColor = (color: string): boolean => {
+  return (
+    isValidColor(color) && (color === "transparent" || isRgbaAlphaZero(color))
+  );
+};

package/manifestUtils/_internals/index.js

@@ -157,6 +157,10 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
 
         if (conditions) {
           generatedField.conditional_fields = conditions.map((condition) => {
+            if (condition.section === null) {
+              return { key: condition.key, condition_value: condition.value };
+            }
+
             const section = condition.section ? `${condition.section}/` : "";
 
             return {
@@ -164,6 +168,8 @@ function generateFieldsFromDefaultsWithoutPrefixedLabel(
               condition_value: condition.value,
             };
           });
+
+          generatedField.rules = "all_conditions";
         }
 
         return generatedField;

package/manifestUtils/defaultManifestConfigurations/generalContent.js

@@ -308,6 +308,41 @@ const generalContent = () => ({
         key: "pull_to_refresh_enabled",
         initial_value: false,
       },
+      {
+        type: "switch",
+        label: "Allow using this screen as a hook",
+        label_tooltip:
+          "Make sure that screen uses 'finishHook' action or performs navigation action to exit the screen after performing the hook action, or user will be stuck on the screen", // eslint-disable-line max-len
+        key: "available_as_hook",
+        initial_value: false,
+      },
+      {
+        type: "data_source_selector",
+        label: "Skip hook endpoint",
+        key: "skip_hook_endpoint",
+        label_tooltip:
+          "If set, this endpoint will check with the server whether the hook should be skipped",
+        conditional_fields: [
+          {
+            key: "rules/available_as_hook",
+            condition_value: true,
+          },
+        ],
+      },
+      {
+        key: "skip_hook_storage_key",
+        type: "text_input",
+        label: "Hook will be skipped if storage key is set",
+        initial_value: "",
+        label_tooltip:
+          "Comma-separated keys in namespace.key format (key without a dot uses the default namespace)", // eslint-disable-line max-len
+        conditional_fields: [
+          {
+            key: "rules/available_as_hook",
+            condition_value: true,
+          },
+        ],
+      },
     ],
   },
 });

package/manifestUtils/fieldUtils/__tests__/fieldUtils.test.js

@@ -1,9 +1,93 @@
 const {
+  parseShorthand,
+  margin,
+  padding,
   withConditional,
   getConditionalKey,
   createConditionalField,
 } = require("..");
 
+describe("parseShorthand", () => {
+  it("1 value → all four sides equal", () => {
+    expect(parseShorthand("8")).toEqual([8, 8, 8, 8]);
+  });
+
+  it("2 values → top/bottom, right/left", () => {
+    expect(parseShorthand("0 20")).toEqual([0, 20, 0, 20]);
+  });
+
+  it("3 values → top, right/left, bottom", () => {
+    expect(parseShorthand("0 0 20")).toEqual([0, 0, 20, 0]);
+  });
+
+  it("4 values → top right bottom left", () => {
+    expect(parseShorthand("1 2 3 4")).toEqual([1, 2, 3, 4]);
+  });
+
+  it("throws on invalid count", () => {
+    expect(() => parseShorthand("1 2 3 4 5")).toThrow();
+  });
+});
+
+describe("margin", () => {
+  it("returns 4 field descriptors with correct suffixes", () => {
+    const fields = margin("margin", { mobile: "0" });
+
+    expect(fields.map((f) => f.suffix)).toEqual([
+      "margin top",
+      "margin right",
+      "margin bottom",
+      "margin left",
+    ]);
+  });
+
+  it("sets type to number_input", () => {
+    margin("margin", { mobile: "0" }).forEach((f) => {
+      expect(f.type).toBe("number_input");
+    });
+  });
+
+  it("expands shorthand per platform", () => {
+    const fields = margin("margin", { mobile: "0 0 20", tv: "0 0 90" });
+    const byKey = Object.fromEntries(fields.map((f) => [f.suffix, f]));
+    expect(byKey["margin top"].initialValue).toEqual({ mobile: 0, tv: 0 });
+    expect(byKey["margin bottom"].initialValue).toEqual({ mobile: 20, tv: 90 });
+    expect(byKey["margin left"].initialValue).toEqual({ mobile: 0, tv: 0 });
+  });
+
+  it("supports a custom suffix prefix", () => {
+    const fields = margin("input margin", { mobile: "4" });
+    expect(fields[0].suffix).toBe("input margin top");
+  });
+});
+
+describe("padding", () => {
+  it("returns 4 field descriptors with correct suffixes", () => {
+    const fields = padding("padding", { mobile: "0" });
+
+    expect(fields.map((f) => f.suffix)).toEqual([
+      "padding top",
+      "padding right",
+      "padding bottom",
+      "padding left",
+    ]);
+  });
+
+  it("expands 2-value shorthand symmetrically", () => {
+    const fields = padding("padding", { mobile: "0 20", tv: "0 124" });
+    const byKey = Object.fromEntries(fields.map((f) => [f.suffix, f]));
+
+    expect(byKey["padding right"].initialValue).toEqual({
+      mobile: 20,
+      tv: 124,
+    });
+
+    expect(byKey["padding left"].initialValue).toEqual({ mobile: 20, tv: 124 });
+    expect(byKey["padding top"].initialValue).toEqual({ mobile: 0, tv: 0 });
+    expect(byKey["padding bottom"].initialValue).toEqual({ mobile: 0, tv: 0 });
+  });
+});
+
 describe("manifestUtils/fieldUtils", () => {
   it("appends conditions and adds all_conditions when there is more than one condition", () => {
     const config = {

package/manifestUtils/fieldUtils/index.js

@@ -1,3 +1,121 @@
+const { ZAPPIFEST_FIELDS } = require("../keys");
+const { toCamelCase } = require("../_internals");
+
+const SIDES = ["top", "right", "bottom", "left"];
+
+/**
+ * Parses a CSS margin/padding shorthand string into [top, right, bottom, left].
+ *
+ * 1 value  → all four sides
+ * 2 values → top/bottom, right/left
+ * 3 values → top, right/left, bottom
+ * 4 values → top, right, bottom, left
+ *
+ * @param {string} str
+ * @returns {[number, number, number, number]}
+ */
+function parseShorthand(str) {
+  const parts = String(str).trim().split(/\s+/).map(Number);
+
+  switch (parts.length) {
+    case 1:
+      return [parts[0], parts[0], parts[0], parts[0]];
+    case 2:
+      return [parts[0], parts[1], parts[0], parts[1]];
+    case 3:
+      return [parts[0], parts[1], parts[2], parts[1]];
+    case 4:
+      return parts;
+    default:
+      throw new Error(
+        `Shorthand expects 1–4 space-separated values, got ${parts.length}: "${str}"`
+      );
+  }
+}
+
+function spacingFields(prefix, initialValues) {
+  const platforms = Object.keys(initialValues);
+
+  const parsed = Object.fromEntries(
+    platforms.map((p) => [p, parseShorthand(initialValues[p])])
+  );
+
+  return SIDES.map((side, i) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+    initialValue: Object.fromEntries(platforms.map((p) => [p, parsed[p][i]])),
+  }));
+}
+
+/**
+ * Generates four margin field descriptors (top/right/bottom/left) from a
+ * per-platform CSS shorthand string.
+ *
+ * @param {string} suffix - prefix word for generated field names, e.g. "margin"
+ * @param {Record<string, string>} initialValues - e.g. { mobile: "0 0 20", tv: "0 0 90" }
+ * @returns {object[]}
+ */
+function margin(suffix, initialValues) {
+  return spacingFields(suffix, initialValues);
+}
+
+/**
+ * Generates four padding field descriptors (top/right/bottom/left) from a
+ * per-platform CSS shorthand string.
+ *
+ * @param {string} suffix - prefix word for generated field names, e.g. "padding"
+ * @param {Record<string, string>} initialValues - e.g. { mobile: "0 20", tv: "0 124" }
+ * @returns {object[]}
+ */
+function padding(suffix, initialValues) {
+  return spacingFields(suffix, initialValues);
+}
+
+/**
+ * Returns a flat camelCase defaults object for a spacing shorthand.
+ * e.g. marginDefaults("margin", "0 0 20") → { marginTop: 0, marginRight: 0, marginBottom: 20, marginLeft: 0 }
+ *
+ * @param {string} suffix - e.g. "margin" or "padding"
+ * @param {string} shorthand - CSS-like shorthand string
+ * @returns {Record<string, number>}
+ */
+function spacingDefaults(suffix, shorthand) {
+  const values = parseShorthand(shorthand);
+
+  return Object.fromEntries(
+    SIDES.map((side, i) => [toCamelCase(`${suffix} ${side}`), values[i]])
+  );
+}
+
+function marginDefaults(suffix, shorthand) {
+  return spacingDefaults(suffix, shorthand);
+}
+
+function paddingDefaults(suffix, shorthand) {
+  return spacingDefaults(suffix, shorthand);
+}
+
+/**
+ * Returns four field descriptors (top/right/bottom/left) with only suffix and type — no initialValue.
+ * Used when defaults are stored separately in the subgroup spec.
+ *
+ * @param {string} prefix - e.g. "margin" or "padding"
+ * @returns {object[]}
+ */
+function marginFields(prefix) {
+  return SIDES.map((side) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+  }));
+}
+
+function paddingFields(prefix) {
+  return SIDES.map((side) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+  }));
+}
+
 /**
  * Appends new conditional_fields from conditions array
  * to config.conditional_fields
@@ -48,6 +166,13 @@ function createConditionalField(key, condition_value, category = "styles") {
 }
 
 module.exports = {
+  parseShorthand,
+  margin,
+  padding,
+  marginDefaults,
+  paddingDefaults,
+  marginFields,
+  paddingFields,
   withConditional,
   getConditionalKey,
   createConditionalField,

package/manifestUtils/index.js

@@ -31,7 +31,7 @@ const {
 } = require("./secondaryImage");
 
 const DEFAULT_GRADIENT_IMAGE =
-  "data:image/png;base64,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";
+  "data:image/png;base64,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";
 
 module.exports = {
   fontKey,

package/manifestUtils/keys.js

@@ -43,6 +43,7 @@ const TV_PLATFORMS = [
   "tvos_for_quickbrick",
   "samsung_tv",
   "lg_tv",
+  "vidaa",
   "vizio",
 ];
 
@@ -630,6 +631,14 @@ const MOBILE_ACTION_BUTTON_FIELDS = [
     type: ZAPPIFEST_FIELDS.number_input,
     suffix: "margin left",
   },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "horizontal gutter",
+  },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "vertical gutter",
+  },
 ];
 
 const TV_MENU_LABEL_FIELDS = [

package/manifestUtils/mobileAction/button/index.js

@@ -129,6 +129,22 @@ function mobileActionButton({ label, description, defaults, isFirstButton }) {
       conditions.push(createConditionalField(labelEnabledKey, true));
     }
 
+    const assetAlignmentKey = keyPrefixGenerator("asset_alignment");
+
+    // horizontal_gutter fields depends on [asset_alignment: left or asset_alignment: right]
+    if (isKeyHasSuffix("horizontal_gutter", key)) {
+      conditions.push(
+        createConditionalField(assetAlignmentKey, ["left", "right"])
+      );
+    }
+
+    // vertical_gutter fields depends on [asset_alignment: above or asset_alignment: below]
+    if (isKeyHasSuffix("vertical_gutter", key)) {
+      conditions.push(
+        createConditionalField(assetAlignmentKey, ["above", "below"])
+      );
+    }
+
     return withConditional(conditions)(field);
   });
 

package/manifestUtils/mobileAction/container/index.js

@@ -49,7 +49,9 @@ function mobileActionButtonsContainer({ label, description, defaults }) {
 
     // over_image_position depends on [positionKey: over_image]
     if (isKeyHasSuffix("over_image_position", key)) {
-      conditions.push(createConditionalField(positionKey, "over_image"));
+      conditions.push(
+        createConditionalField(positionKey, defaults.position[0])
+      );
     }
 
     // horizontal_gutter depends on [stackingKey: horizontal]

package/manifestUtils/mobileAction/groups/defaults.js

@@ -33,7 +33,7 @@ const DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS = {
   assetHeight: 24,
   assetWidth: 24,
   assetMarginTop: 0,
-  assetMarginRight: 6,
+  assetMarginRight: 0,
   assetMarginBottom: 0,
   assetMarginLeft: 0,
   labelEnabled: true,
@@ -50,6 +50,8 @@ const DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS = {
   marginRight: 0,
   marginBottom: 0,
   marginLeft: 0,
+  horizontalGutter: 8,
+  verticalGutter: 8,
 };
 
 const DEFAULT_MOBILE_ACTION_BUTTON_PRESETS = {

package/manifestUtils/platformIsTV.js

@@ -4,6 +4,7 @@ function platformIsTV(platform) {
     "android_tv_for_quickbrick",
     "amazon_fire_tv_for_quickbrick",
     "lg_tv",
+    "vidaa",
     "samsung_tv",
     "web",
     "vizio",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-alpha.9803580571",
+  "version": "16.0.0-alpha.9953202182",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-alpha.9803580571",
+    "@applicaster/applicaster-types": "16.0.0-alpha.9953202182",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",