Refactor/set data action

packages/data-models/flowTypes.ts

@@ -432,6 +432,7 @@ export namespace FlowTypes {
     "pop_up",
     "process_template",
     "reset_app",
+    "reset_data",
     "save_to_device",
     "screen_orientation",
     "set_field",

packages/shared/src/models/templatedData/templatedData.spec.ts

@@ -5,7 +5,7 @@ interface ITestData {
   output: any; // Expected end parsed data
 }
 
-/** This context is applied to all tests. Input will be processed for subsitition into output */
+/** This context is applied to all tests. Input will be processed for substitution into output */
 const context = {
   input: {
     row: {
@@ -127,37 +127,38 @@ describe("Templated Data Parsing", () => {
 });
 
 /**
- * Text extract method of
+ * Text extract method
+ * yarn workspace shared test --filter "Templated Data Extraction"
  */
 describe("Templated Data Extraction", () => {
   const extractTests: ITestData[] = [
     {
       input: "hello @row.value_1 @row.value_2",
-      output: { row: { value_1: true, value_2: true } },
+      output: { row: { value_1: "", value_2: "" } },
     },
     {
       input: "hello @row.value_1.child_property",
-      output: { row: { value_1: true } },
+      output: { row: { value_1: "" } },
     },
     {
       input: "@unknown_prefix.value",
       output: {},
     },
     {
       input: "@[email protected]_value",
-      output: { row: { __recursive: true, recursive_value: true } },
+      output: { row: { "*": "", recursive_value: "" } },
     },
     {
       input: "@row.row_value @field.field_value",
-      output: { row: { row_value: true }, field: { field_value: true } },
+      output: { row: { row_value: "" }, field: { field_value: "" } },
     },
     {
       input: {
         string: "hello @row.value_1",
         array: ["@row.value_2", "@row.value_3"],
         nested: { string: ["@row.value_4"] },
       },
-      output: { row: { value_1: true, value_2: true, value_3: true, value_4: true } },
+      output: { row: { value_1: "", value_2: "", value_3: "", value_4: "" } },
     },
   ];
   // Test individual string parsing
@@ -170,8 +171,8 @@ describe("Templated Data Extraction", () => {
     const { input, output } = testData;
     it(JSON.stringify(input), () => {
       const parser = new TemplatedData();
-      const parsedValue = parser.listContextVariables(input, ["row", "field"]);
-      expect(parsedValue).toEqual(output);
+      const contextVariables = parser.listContextVariables(input, ["row", "field"]);
+      expect(contextVariables).toEqual(output);
       // process.nextTick(() => console.log(`      ${JSON.stringify(parsedValue)}\n`));
     });
   }

packages/shared/src/models/templatedData/templatedData.ts

@@ -1,23 +1,12 @@
 import { ITemplatedStringVariable } from "../../types";
 import { addStringDelimiters, extractDelimitedTemplateString } from "../../utils/delimiters";
 import { isObjectLiteral } from "../../utils/object-utils";
-
-type ITemplatedDataContext = { [prefix: string]: any };
+import type { FlowTypes } from "data-models";
 
 /** Hashmap of all context-based variable names used in expression, organised by prefix, e.g.
- * `{ field: {some_field_name: true}, row: {some_row_name:true, another_name: true}}`
+ * `{ field: {some_field_name: ""}, row: {some_row_name:"", another_name: ""}}`
  */
-
-export interface ITemplatedDataContextList {
-  [contextPrefix: string]: {
-    [contextVariableName: string]: boolean;
-    /**
-     * Track whether variable list known to contain recursive variables that will
-     * require runtime evaluation, e.g. `{ field: {some_field_name: true, __recursive: true}`
-     */
-    __recursive?: boolean;
-  };
-}
+export type ITemplatedDataContext = { [prefix in FlowTypes.IDynamicPrefix]?: Record<string, any> };
 
 /**
  * Templated data class contains methods to to convert data containing dynamic context variables
@@ -31,12 +20,15 @@ export class TemplatedData {
   /** Value returned after parsing templated data, e.g. `"Hello example_1"` */
   public parsedValue: any;
 
-  /** json object containing namespaced values for context replacements
+  /** json object containing flattened values for context replacements
    * ```
-   * {row:{id:"example_1"}}
+   * {
+   *  "@row":{id:"example_1"}
+   *  "@row.id": "example_1"
+   * }
    * ```
    */
-  public parsedContext: ITemplatedDataContext;
+  public parsedContext: Record<string, any>;
 
   /** List of all prefixes used in context, e.g `["row"]` */
   private contextPrefixes: string[] = [];
@@ -74,19 +66,20 @@ export class TemplatedData {
    * Iterate over data, parse string values and nested objects and arrays recursively
    */
   public parse<T>(value: T) {
-    if (value) {
-      if (typeof value === "string") {
-        value = this.parseTemplatedString(value);
-      }
-      // recursively convert array and json-like objects
-      if (Array.isArray(value)) {
-        value = value.map((v) => this.parse(v)) as any;
-      }
-      if (isObjectLiteral(value)) {
-        for (const [key, nestedValue] of Object.entries(value)) {
-          value[key] = this.parse(nestedValue);
-        }
+    if (typeof value === "string") {
+      return this.parseTemplatedString(value);
+    }
+    // recursively convert array and json-like objects
+    if (Array.isArray(value)) {
+      return value.map((v) => this.parse(v)) as any;
+    }
+    if (isObjectLiteral(value)) {
+      // create a new object to avoid changes to input
+      const parsed = {};
+      for (const [key, nestedValue] of Object.entries(value)) {
+        parsed[key] = this.parse(nestedValue);
       }
+      return parsed;
     }
     return value;
   }
@@ -96,12 +89,12 @@ export class TemplatedData {
    * detected within data value
    **/
   public listContextVariables(value: any, prefixes: string[] = []) {
-    let contextVariables: ITemplatedDataContextList = {};
+    let contextVariables: ITemplatedDataContext = {};
 
     // Recursively extract any nested context strings
     function extractContext(contextValue: any) {
       if (contextValue) {
-        if ({}.constructor === contextValue.constructor) {
+        if (isObjectLiteral(contextValue)) {
           extractContext(Object.values(contextValue));
         }
         if (Array.isArray(contextValue)) {
@@ -126,17 +119,18 @@ export class TemplatedData {
       }
 
       // Populate any variables identified from processed strings to context variable list
-      // Include recursive handling when detected nested, e.g. @[email protected]_lookup
+      // Include handling when detected nested, e.g. @[email protected]_lookup
       function populateContextVariables(entries: ITemplatedStringVariable[]) {
         for (const entry of entries) {
           let [prefix, name] = entry.value.split(".");
           prefix = prefix.replace("@", "");
           contextVariables[prefix] ??= {};
+          // recursive variables - keep wildcard reference and process inner
           if (entry.variables) {
-            contextVariables[prefix].__recursive = true;
+            contextVariables[prefix]["*"] = "";
             populateContextVariables(Object.values(entry.variables));
           } else {
-            contextVariables[prefix][name] = true;
+            contextVariables[prefix][name] = "";
           }
         }
       }
@@ -147,7 +141,7 @@ export class TemplatedData {
 
   /**
    * Take a string and replace instances of context variables, such as `"hello {@row.name}"`
-   * Will convert non-delimited strings to delimted, extract list of variables and parse
+   * Will convert non-delimited strings to delimited, extract list of variables and parse
    */
   private parseTemplatedString(value: string) {
     const delimited = addStringDelimiters(value, this.contextPrefixes);

packages/shared/src/utils/object-utils.ts

@@ -100,8 +100,7 @@ export function isEqual(a: any, b: any) {
     if (!isEqual(Object.keys(aSorted), Object.keys(bSorted))) return false;
     return isEqual(Object.values(aSorted), Object.values(bSorted));
   }
-  // could not compare (e.g. symbols, date objects, functions, buffers etc)
-  console.warn(`[isEqual] could not compare`, a, b);
+  // NOTE - does not compare symbols, date objects, functions, buffers etc.
   return false;
 }
 

src/app/shared/components/template/components/button/button.component.scss

@@ -217,4 +217,4 @@ ion-button[data-variant~="card"] {
   @media (max-width: 320px) {
     max-width: 10rem;
   }
-}
+}

src/app/shared/components/template/components/data-items/data-items.actions.spec.ts

@@ -0,0 +1,58 @@
+import type { FlowTypes } from "packages/data-models";
+import { DataItemsActionService } from "./data-items.actions";
+import { generateItemMeta } from "./data-items.utils";
+
+/***********************************************************************************************
+ * Mock Data
+ **********************************************************************************************/
+
+const MOCK_ITEMS_LIST: FlowTypes.Data_listRow[] = [
+  { id: "id_1", text: "item 1", number: 1, boolean: true },
+  { id: "id_2", text: "item 2", number: 2, boolean: false },
+];
+
+const MOCK_TEMPLATE_ROW: FlowTypes.TemplateRow = {
+  _nested_name: "",
+  name: "",
+  type: "button",
+  value: "@item.text",
+};
+
+/**
+ * Mock structure for `begin_data_items .... end_data_items` syntax
+ * The list provided in `value` will be used to source data_list items, and the `rows`
+ * nested will be templated from the items
+ */
+const MOCK_DATA_ITEMS_ROW: FlowTypes.TemplateRow = {
+  _nested_name: "",
+  name: "",
+  type: "data_items",
+  value: "@data.mock_item_list",
+  rows: [MOCK_TEMPLATE_ROW],
+};
+
+/**
+ * Call standalone tests via:
+ * yarn ng test --include src/app/shared/components/template/components/data-items/data-items.utils.spec.ts
+ */
+describe("DataItems Utils", () => {
+  service: DataItemsActionService;
+
+  fit("convertItemActionToSetDataAction", () => {
+    const itemListRows = generateItemMeta(MOCK_ITEMS_LIST);
+    // const res = convertItemActionToSetDataAction({
+    //   action: {
+    //     action_id: "set_item",
+    //     args: [],
+    //     trigger: "click",
+    //     // advanced example
+    //     // target the next item and update relative text to that item
+    //     params: { _index: "@item._index+1", text: "{@item.text} updated" },
+    //   },
+    //   dataListName: "mock_list",
+    //   itemContext: itemListRows[0],
+    //   itemListRows,
+    // });
+    // console.log("res", res);
+  });
+});