@applicaster/zapp-react-native-utils 16.0.0-alpha.3234316524 → 16.0.0-alpha.3345515557

package/actionsExecutor/ActionExecutorContext.tsx

@@ -7,6 +7,7 @@ import {
 } from "./ActionExecutor";
 import {
   batchRemoveAllFromNamespaceForStorage,
+  batchRemoveFromStorage,
   batchSave,
 } from "../zappFrameworkUtils/localStorageHelper";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
@@ -38,13 +39,17 @@ import {
 } from "./StorageActions";
 
 import { screenSetVariable, screenToggleFlag } from "./ScreenActions";
+import {
+  StorageValuesToAdd,
+  StorageValuesToRemove,
+} from "../zappFrameworkUtils/types";
 
 export const { log_error, log_info, log_debug } = createLogger({
   subsystem: "ActionExecutorContext",
   category: "General",
 });
 
-type ActionExecutorContextType = {
+export type ActionExecutorContextType = {
   registerAction: (
     type: string,
     handler: (
@@ -66,6 +71,7 @@ type ActionExecutorContextType = {
     context?: Record<string, any>
   ) => Promise<ActionResult>;
 };
+
 type Props = {
   children: React.ReactNode;
 };
@@ -88,7 +94,7 @@ function findParentComponent(
 
 const prepareDefaultActions = (actionExecutor) => {
   actionExecutor.registerAction("localStorageSet", async (action) => {
-    const namespaces = action.options.content;
+    const namespaces: StorageValuesToAdd = action.options.content;
     await batchSave(namespaces, localStorage);
     // TODO: Add support for ownershipKey and ownershipNamespace
 
@@ -96,13 +102,29 @@ const prepareDefaultActions = (actionExecutor) => {
   });
 
   actionExecutor.registerAction("sessionStorageSet", async (action) => {
-    const namespaces = action.options.content;
+    const namespaces: StorageValuesToAdd = action.options.content;
     await batchSave(namespaces, sessionStorage);
     // TODO: Add support for ownershipKey and ownershipNamespace
 
     return ActionResult.Success;
   });
 
+  actionExecutor.registerAction("localStorageRemove", async (action) => {
+    const namespaces: StorageValuesToRemove = action.options.content;
+    await batchRemoveFromStorage(namespaces, localStorage);
+    // TODO: Add support for ownershipKey and ownershipNamespace
+
+    return ActionResult.Success;
+  });
+
+  actionExecutor.registerAction("sessionStorageRemove", async (action) => {
+    const namespaces: StorageValuesToRemove = action.options.content;
+    await batchRemoveFromStorage(namespaces, sessionStorage);
+    // TODO: Add support for ownershipKey and ownershipNamespace
+
+    return ActionResult.Success;
+  });
+
   actionExecutor.registerAction(
     "refreshComponent",
     async (_action, context) => {
@@ -129,7 +151,7 @@ const prepareDefaultActions = (actionExecutor) => {
           getInflatedDataSourceUrl({
             source,
             contexts: {
-              entry: context?.entryContext,
+              entry: context?.screenEntry,
               screen: context?.screenData,
               search: getSearchContext(null, mapping),
             },
@@ -198,7 +220,7 @@ const prepareDefaultActions = (actionExecutor) => {
 
       const entry = context?.entry || {};
       const entryResolver = new EntryResolver(entry);
-      const screenData = context?.screenStateStore.getState().data || {};
+      const screenData = context?.screenStateStore?.getState().data || {};
       const screenResolver = new EntryResolver(screenData || {});
 
       const data =

package/analyticsUtils/AnalyticsEvents/sendMenuClickEvent.ts

@@ -6,9 +6,9 @@ import { postAnalyticEvent } from "../manager";
 import { ANALYTICS_CORE_EVENTS } from "../events";
 
 type AnalyticsDefaultHelperProperties = {
-  analyticsScreenData: AnalyticsScreenProperties;
+  analyticsScreenData?: AnalyticsScreenProperties;
   extraProps: any;
-  props;
+  props?: any;
 };
 
 export const sendMenuClickEvent = ({

package/analyticsUtils/PlayerAnalyticsManager.ts

@@ -23,6 +23,15 @@ class PlayerAnalyticsTrackerFactory {
         return new PlayerAnalyticsTracker();
     }
   }
+
+  onPlayerRegistered(tracker: PlayerAnalyticsTrackerI, player: Player) {
+    tracker.setPlayer(player);
+    tracker.onPlayerPresented();
+  }
+
+  onPlayerUnRegistered(tracker?: PlayerAnalyticsTrackerI) {
+    tracker?.onPlayerClosed();
+  }
 }
 
 export class PlayerAnalyticsManager implements PlayerLifecycleListener {
@@ -70,7 +79,7 @@ export class PlayerAnalyticsManager implements PlayerLifecycleListener {
     }
 
     const tracker = this.getTracker(player.playerId);
-    tracker.setPlayer(player);
+    this.trackerFactory.onPlayerRegistered(tracker, player);
 
     const analyticsListener = new AnalyticPlayerListener({
       analyticsTracker: tracker,
@@ -84,6 +93,7 @@ export class PlayerAnalyticsManager implements PlayerLifecycleListener {
   };
 
   onUnRegistered = (player: Player) => {
+    this.trackerFactory.onPlayerUnRegistered(this.trackers[player.playerId]);
     player.removeListener(AnalyticPlayerListener.analyticsListenerID);
     delete this.trackers[player.playerId];
   };

package/analyticsUtils/__tests__/analyticsMapper.test.ts

@@ -74,4 +74,39 @@ describe("Analytics Mapper", () => {
     const rules = fixtures.ACPEventRules;
     await setConfigRunMapTest(rules, fixtures.ACPEventEvents);
   });
+
+  it("Does not let an ignore rule short-circuit later events", async () => {
+    await setConfigRunMapTest(
+      fixtures.ignoreOrderingRules,
+      fixtures.ignoreOrderingEvents
+    );
+  });
+
+  it("Keeps the original name when rename is empty", async () => {
+    await setConfigRunMapTest(
+      fixtures.emptyRenameRules,
+      fixtures.emptyRenameEvents
+    );
+  });
+
+  it("Renames via a regex with no named groups", async () => {
+    await setConfigRunMapTest(
+      fixtures.regexNonNamedFullMatchRules,
+      fixtures.regexNonNamedFullMatchEvents
+    );
+  });
+
+  it("Substitutes every named group in a regex rename", async () => {
+    await setConfigRunMapTest(
+      fixtures.regexMultiGroupRenameRules,
+      fixtures.regexMultiGroupRenameEvents
+    );
+  });
+
+  it("Does not fall back to event match when a regex rule does not match", async () => {
+    await setConfigRunMapTest(
+      fixtures.regexEventNoFallbackRules,
+      fixtures.regexEventNoFallbackEvents
+    );
+  });
 });

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testACP_events.json

@@ -23,7 +23,7 @@
     "second": {
       "name": "EventName",
       "params": {
-        "acp": 1
+        "acp": "1"
       }
     }
   }

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testBlockUnlistedParams_rules.json

@@ -12,4 +12,4 @@
     }
   ],
   "strategy": "allowUnlisted"
-}
+}

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testEmptyRenameKeepsName_events.json

@@ -0,0 +1,4 @@
+[
+  { "first": { "name": "keep_me", "params": {} },
+    "second": { "name": "keep_me", "params": {} } }
+]

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testEmptyRenameKeepsName_rules.json

@@ -0,0 +1,6 @@
+{
+  "rules": [
+    { "event": "keep_me", "ignore": false, "rename": "", "strategy": "allowUnlisted" }
+  ],
+  "strategy": "allowUnlisted"
+}

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testEventRegex_events.json

@@ -2,17 +2,11 @@
   {
     "first": {
       "name": "Screen viewed: Ads & redirects",
-      "params": {
-        "ignored_param": "removed_value",
-        "kept_param": "kept_value"
-      }
+      "params": {}
     },
     "second": {
       "name": "Screen Ads & redirects",
-      "params": {
-        "ignored_param": "removed_value",
-        "kept_param": "kept_value"
-      }
+      "params": {}
     }
   }
-]
+]

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testIgnoreOrdering_events.json

@@ -0,0 +1,18 @@
+[
+  {
+    "first": {
+      "name": "screen_view",
+      "params": {}
+    },
+    "second": {
+      "name": "page_view",
+      "params": {}
+    }
+  },
+  {
+    "first": {
+      "name": "player_presented",
+      "params": {}
+    }
+  }
+]

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testIgnoreOrdering_rules.json

@@ -0,0 +1,16 @@
+{
+  "rules": [
+    {
+      "event": "player_presented",
+      "ignore": true,
+      "strategy": "allowUnlisted"
+    },
+    {
+      "event": "screen_view",
+      "ignore": false,
+      "rename": "page_view",
+      "strategy": "allowUnlisted"
+    }
+  ],
+  "strategy": "allowUnlisted"
+}

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testRegexEventNoFallback_events.json

@@ -0,0 +1,4 @@
+[
+  { "first": { "name": "my_event", "params": {} },
+    "second": { "name": "my_event", "params": {} } }
+]

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testRegexEventNoFallback_rules.json

@@ -0,0 +1,6 @@
+{
+  "rules": [
+    { "event": "my_event", "ignore": false, "rename": "should_not_apply", "regex": "wont_match_.*", "strategy": "allowUnlisted" }
+  ],
+  "strategy": "allowUnlisted"
+}

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testRegexMultiGroupRename_events.json

@@ -0,0 +1,4 @@
+[
+  { "first": { "name": "play-video", "params": {} },
+    "second": { "name": "play_video", "params": {} } }
+]

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testRegexMultiGroupRename_rules.json

@@ -0,0 +1,6 @@
+{
+  "rules": [
+    { "ignore": false, "rename": "$<first>_$<second>", "regex": "(?<first>[a-z]+)-(?<second>[a-z]+)", "strategy": "allowUnlisted" }
+  ],
+  "strategy": "allowUnlisted"
+}

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testRegexNonNamedFullMatch_events.json

@@ -0,0 +1,4 @@
+[
+  { "first": { "name": "screen_view", "params": {} },
+    "second": { "name": "renamed", "params": {} } }
+]

package/analyticsUtils/__tests__/fixtures/analytics_mapper_testRegexNonNamedFullMatch_rules.json

@@ -0,0 +1,6 @@
+{
+  "rules": [
+    { "ignore": false, "rename": "renamed", "regex": "screen_view", "strategy": "allowUnlisted" }
+  ],
+  "strategy": "allowUnlisted"
+}

package/analyticsUtils/__tests__/fixtures/index.js

@@ -14,6 +14,16 @@ import blockUnlistedEventEvents from "./analytics_mapper_testBlockUnlistedEvents
 import blockUnlistedEventRules from "./analytics_mapper_testBlockUnlistedEvents_rules.json";
 import ACPEventEvents from "./analytics_mapper_testACP_events.json";
 import ACPEventRules from "./analytics_mapper_testACP_rules.json";
+import emptyRenameRules from "./analytics_mapper_testEmptyRenameKeepsName_rules.json";
+import emptyRenameEvents from "./analytics_mapper_testEmptyRenameKeepsName_events.json";
+import ignoreOrderingRules from "./analytics_mapper_testIgnoreOrdering_rules.json";
+import ignoreOrderingEvents from "./analytics_mapper_testIgnoreOrdering_events.json";
+import regexEventNoFallbackRules from "./analytics_mapper_testRegexEventNoFallback_rules.json";
+import regexEventNoFallbackEvents from "./analytics_mapper_testRegexEventNoFallback_events.json";
+import regexMultiGroupRenameRules from "./analytics_mapper_testRegexMultiGroupRename_rules.json";
+import regexMultiGroupRenameEvents from "./analytics_mapper_testRegexMultiGroupRename_events.json";
+import regexNonNamedFullMatchRules from "./analytics_mapper_testRegexNonNamedFullMatch_rules.json";
+import regexNonNamedFullMatchEvents from "./analytics_mapper_testRegexNonNamedFullMatch_events.json";
 
 export const fixtures = {
   renameRules,
@@ -32,4 +42,14 @@ export const fixtures = {
   blockUnlistedEventRules,
   ACPEventEvents,
   ACPEventRules,
+  emptyRenameRules,
+  emptyRenameEvents,
+  ignoreOrderingRules,
+  ignoreOrderingEvents,
+  regexEventNoFallbackRules,
+  regexEventNoFallbackEvents,
+  regexMultiGroupRenameRules,
+  regexMultiGroupRenameEvents,
+  regexNonNamedFullMatchRules,
+  regexNonNamedFullMatchEvents,
 };

package/analyticsUtils/analyticsMapper.ts

@@ -76,7 +76,10 @@ class StateHolder {
       delete this.pluckedParams[prefix];
     }
 
-    return this._cap?.[suffix];
+    // Stringify so values match the native iOS/Android mappers (which coerce
+    // analyticsCustomProperties values to strings) — keeps GA4 data consistent
+    // across web/LG/Samsung and native platforms.
+    return this._cap?.[suffix]?.toString() ?? null;
   }
 
   private async getFromLocalAndSession(

package/analyticsUtils/playerAnalyticsTracker.ts

@@ -4,8 +4,14 @@ import { isTrue } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { postAnalyticEvent } from "./manager";
 import { isLive } from "../playerUtils";
 import { extensionsEvents } from "./AnalyticsEvents/helper";
-import { AD_EVENT, EVENT_TYPES, PLAYER_DISPLAY_STATES } from "./events";
+import {
+  AD_EVENT,
+  EVENT_TYPES,
+  GENERAL_EVENT,
+  PLAYER_DISPLAY_STATES,
+} from "./events";
 import { Player } from "../appUtils/playerManager/player";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
 
 export interface PlayerAnalyticsTrackerI {
   handleAnalyticEvent(
@@ -13,6 +19,8 @@ export interface PlayerAnalyticsTrackerI {
     eventData?: QuickBrickPlayer.EventData
   ): void;
   setPlayer(player: Player): void;
+  onPlayerPresented(): void;
+  onPlayerClosed(): void;
 }
 
 export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
@@ -26,6 +34,15 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
     this.player = player;
   }
 
+  onPlayerPresented() {
+    this.handleAnalyticEvent(GENERAL_EVENT.player_presented);
+  }
+
+  onPlayerClosed() {
+    this.handleAnalyticEvent(GENERAL_EVENT.session_end);
+    this.handleAnalyticEvent(GENERAL_EVENT.player_closed);
+  }
+
   isAdBreak(event: string): boolean {
     const adBreakEvents = [
       AD_EVENT.ad_break_start,
@@ -180,7 +197,8 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
       this.entry?.extensions?.free || this.entry?.extensions?.isFree;
 
     const title = this.entry?.title;
-    const streamType = isLive(this.entry) ? "live" : "vod"; // Todo: determine other types, channel, podcast, aod
+    const isStreamLive = isLive(this.entry);
+    const streamType = isStreamLive ? "live" : "vod"; // Todo: determine other types, channel, podcast, aod
 
     const currentPosition = this.getCurrentPosition(
       event,
@@ -201,6 +219,7 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
     );
 
     const playerState = this.getPlayerState();
+    const playerType = this.player?.playerPluginId;
 
     const analyticsCustomProperties = extensionsEvents(this.entry?.extensions);
 
@@ -210,7 +229,11 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
       name: title,
       media_type: mediaType,
       stream_type: streamType,
-      duration: mediaDuration,
+      player_type: playerType,
+      // We do not pass duration for live streams anymore (it's now seekableDuration),
+      //  but we can't mark it as optional in Analytics Mapper yet,
+      //  so we set it to -1 for live streams
+      duration: isStreamLive && isNil(mediaDuration) ? -1 : mediaDuration,
       current_position: currentPosition,
       player_state: playerState,
       stream_format: contentType,

package/cellUtils/index.ts

@@ -1,7 +1,7 @@
 import * as R from "ramda";
 import { dayjs } from "../dateUtils";
-import validateColor from "validate-color";
 
+import { isValidColor } from "@applicaster/zapp-react-native-utils/colorUtils";
 import { transformColorCode as fixColorHexCode } from "@applicaster/zapp-react-native-utils/transform";
 import {
   capitalize,
@@ -468,15 +468,13 @@ export const getColorFromData = ({
   data,
   valueFromLayout,
 }: GetColorFromData): string => {
-  // Temporary hack to fix color validation when alpha is floating point number
-  // https://github.com/dreamyguy/validate-color/issues/44
-  if (validateColor(valueFromLayout.replace(".00", ""))) {
+  if (isValidColor(valueFromLayout)) {
     return valueFromLayout;
   }
 
   const pathValue = R.path(valueFromLayout.split("."), data);
 
-  if (pathValue && validateColor(pathValue)) {
+  if (pathValue && isValidColor(pathValue)) {
     return pathValue;
   }
 

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;