@processmaker/screen-builder 2.60.0 → 2.60.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@processmaker/screen-builder",
-  "version": "2.60.0",
+  "version": "2.60.1",
   "scripts": {
     "serve": "vue-cli-service serve",
     "build": "vue-cli-service build",
@@ -39,7 +39,7 @@
     "@cypress/code-coverage": "^3.8.1",
     "@fortawesome/fontawesome-free": "^5.6.1",
     "@panter/vue-i18next": "^0.15.2",
-    "@processmaker/vue-form-elements": "0.41.1",
+    "@processmaker/vue-form-elements": "0.41.2",
     "@processmaker/vue-multiselect": "^2.2.0",
     "@vue/cli-plugin-babel": "^3.6.0",
     "@vue/cli-plugin-e2e-cypress": "^4.0.3",
@@ -88,7 +88,7 @@
   },
   "peerDependencies": {
     "@panter/vue-i18next": "^0.15.0",
-    "@processmaker/vue-form-elements": "0.41.1",
+    "@processmaker/vue-form-elements": "0.41.2",
     "i18next": "^15.0.8",
     "vue": "^2.6.12",
     "vuex": "^3.1.1"

package/src/mixins/computedFields.js

@@ -1,5 +1,74 @@
-import { isEqual } from 'lodash';
-import { Parser } from 'expr-eval';
+import { Parser } from "expr-eval";
+
+/**
+ * Gets the screen parent or null if don't have
+ * @returns {object|null}
+ */
+function findScreenOwner(control) {
+  let owner = control.$parent;
+  while (owner) {
+    const isScreen = owner.$options.name === "ScreenContent";
+    const nestedScreen =
+      owner.$parent && owner.$parent.$parent && owner.$parent.$parent.$parent;
+    const isNestedScreen =
+      nestedScreen &&
+      nestedScreen.$options._componentTag === "form-nested-screen";
+    if (isScreen && !isNestedScreen) {
+      return owner;
+    }
+    if (isNestedScreen) {
+      owner = nestedScreen;
+    } else {
+      owner = owner.$parent;
+    }
+  }
+  return null;
+}
+/**
+ * Wrap the data of a control using a Proxy
+ * @return {object} proxy
+ */
+function wrapScreenData(screen, customFunctions = null) {
+  const handler = {
+    get: (target, name) => {
+      if (customFunctions && customFunctions[name]) {
+        return customFunctions[name];
+      }
+      if (name === "_parent") {
+        const screenOwner = findScreenOwner(screen);
+        // Get _parent for the current screen (e.g. Inside Loops, Inside Tabs?, RecordLists...?)
+        if (screenOwner) {
+          return wrapScreenData(screenOwner);
+        }
+        if (screen.vdata) {
+          return screen.vdata._parent;
+        }
+        return undefined;
+      }
+      // Check if vdata exists
+      if (screen.vdata !== undefined && screen.vdata !== null) {
+        return screen.vdata[name];
+      }
+      return undefined;
+    },
+    has(target, name) {
+      // customFunctions is used by RichText controls
+      // to add custom Mustache functions
+      if (screen.customFunctions && screen.customFunctions[name]) {
+        return true;
+      }
+      if (name === "_parent") {
+        return true;
+      }
+      // Check if vdata exists
+      if (screen.vdata !== undefined && screen.vdata !== null) {
+        return screen.vdata[name] !== undefined;
+      }
+      return false;
+    }
+  };
+  return new Proxy({}, handler);
+}
 
 export default {
   methods: {
@@ -12,22 +81,35 @@ export default {
         // vdata (external variables)in this way the event is not
         // executed again when the variable is update
 
-        const data = new Proxy({}, {
-          get(data, name) {
-            if (self[name] === undefined || !isEqual(self[name], self.vdata[name])) {
-              return self.vdata[name];
-            } else {
+        const data = new Proxy(
+          {},
+          {
+            get(data, name) {
+              if (name === "_parent") {
+                // Recursive access to _parent
+                const screen = findScreenOwner(self);
+                const parentScreen = screen && findScreenOwner(screen);
+                if (parentScreen) {
+                  return wrapScreenData(parentScreen);
+                }
+              }
+              if (self.vdata[name] !== undefined) {
+                return self.vdata[name];
+              }
               return self[name];
+            },
+            set() {
+              throw new Error(
+                "You are not allowed to set properties from inside an expression"
+              );
             }
-          },
-          set() {
-            throw 'You are not allowed to set properties from inside an expression';
-          },
-        });
+          }
+        );
 
-        if (type === 'expression') {
+        if (type === "expression") {
           value = Parser.evaluate(expression, data);
         } else {
+          // eslint-disable-next-line no-new-func
           value = new Function(expression).bind(data)();
         }
 
@@ -36,10 +118,9 @@ export default {
         }
 
         return value;
-
       } catch (e) {
-        e;
+        console.warn("There was a problem evaluating the expression", e);
       }
-    },
-  },
+    }
+  }
 };