FIO-10337, FIO-10028: Added performance and data processing improvements for the 2.5.x branch

src/process/calculation/index.ts

@@ -50,6 +50,10 @@ export const calculateProcessSync: ProcessorFnSync<CalculationScope> = (
       value: newValue,
     });
     set(data, path, newValue);
+    if (!scope.filter) scope.filter = {};
+    if (!(scope as any).clearHidden?.hasOwnProperty(path)) {
+      scope.filter[path] = true;
+    }
   }
   return;
 };

src/process/clearHidden/index.ts

@@ -1,14 +1,15 @@
 import { unset } from 'lodash';
 import {
-  ProcessorScope,
   ProcessorContext,
   ProcessorInfo,
   ProcessorFnSync,
   ConditionsScope,
   ProcessorFn,
+  FilterScope,
 } from 'types';
+import { getModelType, setComponentScope } from 'utils/formUtil';
 
-type ClearHiddenScope = ProcessorScope & {
+export type ClearHiddenScope = FilterScope & {
   clearHidden: {
     [path: string]: boolean;
   };
@@ -18,21 +19,32 @@ type ClearHiddenScope = ProcessorScope & {
  * This processor function checks components for the `hidden` property and unsets corresponding data
  */
 export const clearHiddenProcessSync: ProcessorFnSync<ClearHiddenScope> = (context) => {
-  const { component, data, value, scope, path } = context;
+  const { component, data, value, scope, path, parent } = context;
 
-  // No need to unset the value if it's undefined
-  if (value === undefined) {
-    return;
+  // Check if there's a conditional set for the component and if it's marked as conditionally hidden
+  const isConditionallyHidden =
+    parent?.scope?.conditionallyHidden ||
+    (scope as ConditionsScope).conditionals?.find((cond) => {
+      return path === cond.path && cond.conditionallyHidden;
+    });
+
+  if (isConditionallyHidden) {
+    setComponentScope(component, 'conditionallyHidden', true);
   }
 
-  if (!scope.clearHidden) {
-    scope.clearHidden = {};
+  if (
+    parent?.scope?.intentionallyHidden ||
+    (component.hasOwnProperty('hidden') && !!component.hidden)
+  ) {
+    setComponentScope(component, 'intentionallyHidden', true);
   }
 
-  // Check if there's a conditional set for the component and if it's marked as conditionally hidden
-  const isConditionallyHidden = (scope as ConditionsScope).conditionals?.find((cond) => {
-    return path === cond.path && cond.conditionallyHidden;
-  });
+  const compModel = getModelType(component);
+
+  // No need to unset the value if it's undefined or is a non-data component.
+  if (value === undefined || !component.type || compModel === 'none' || compModel === 'content') {
+    return;
+  }
 
   const shouldClearValueWhenHidden =
     !component.hasOwnProperty('clearOnHide') || component.clearOnHide;
@@ -42,7 +54,12 @@ export const clearHiddenProcessSync: ProcessorFnSync<ClearHiddenScope> = (contex
     (isConditionallyHidden || component.scope?.conditionallyHidden)
   ) {
     unset(data, path);
+    if (!scope.clearHidden) scope.clearHidden = {};
     scope.clearHidden[path] = true;
+
+    // Make sure the filter does not include the value back.
+    if (!scope.filter) scope.filter = {};
+    scope.filter[path] = false;
   }
 };
 

src/process/conditions/index.ts

@@ -162,5 +162,5 @@ export const conditionProcessInfo: ProcessorInfo<ConditionsContext, void> = {
   name: 'conditions',
   process: conditionProcess,
   processSync: conditionProcessSync,
-  shouldProcess: hasSimpleConditions,
+  shouldProcess: hasConditions,
 };

src/process/defaultValue/index.ts

@@ -7,7 +7,7 @@ import {
 } from 'types';
 import { set, has } from 'lodash';
 import { evaluate } from 'utils';
-import { getComponentKey } from 'utils/formUtil';
+import { getComponentKey, getModelType } from 'utils/formUtil';
 
 export const hasCustomDefaultValue = (context: DefaultValueContext): boolean => {
   const { component } = context;
@@ -35,10 +35,29 @@ export const customDefaultValueProcess: ProcessorFn<ConditionsScope> = async (
   return customDefaultValueProcessSync(context);
 };
 
+function setDefaultValue(context: DefaultValueContext, defaultValue: any) {
+  const { component, data, scope, path } = context;
+  if (defaultValue === null || defaultValue === undefined) {
+    return;
+  }
+  if (!scope.defaultValues) scope.defaultValues = [];
+  scope.defaultValues.push({
+    path,
+    value: defaultValue,
+  });
+  set(data, path, defaultValue);
+
+  // If this component is not already included in the filter and is not a number, then include it from the default.
+  if (!scope.filter) scope.filter = {};
+  if (!(scope as any).clearHidden?.hasOwnProperty(path) && getModelType(component) !== 'number') {
+    scope.filter[path] = true;
+  }
+}
+
 export const customDefaultValueProcessSync: ProcessorFnSync<ConditionsScope> = (
   context: DefaultValueContext,
 ) => {
-  const { component, row, data, scope, path } = context;
+  const { component, row, scope } = context;
   if (!hasCustomDefaultValue(context)) {
     return;
   }
@@ -58,14 +77,8 @@ export const customDefaultValueProcessSync: ProcessorFnSync<ConditionsScope> = (
     if (component.multiple && !Array.isArray(defaultValue)) {
       defaultValue = defaultValue ? [defaultValue] : [];
     }
-    scope.defaultValues.push({
-      path,
-      value: defaultValue,
-    });
-  }
-  if (defaultValue !== null && defaultValue !== undefined) {
-    set(data, path, defaultValue);
   }
+  setDefaultValue(context, defaultValue);
 };
 
 export const serverDefaultValueProcess: ProcessorFn<ConditionsScope> = async (
@@ -77,7 +90,7 @@ export const serverDefaultValueProcess: ProcessorFn<ConditionsScope> = async (
 export const serverDefaultValueProcessSync: ProcessorFnSync<ConditionsScope> = (
   context: DefaultValueContext,
 ) => {
-  const { component, row, data, scope, path } = context;
+  const { component, row, scope } = context;
   if (!hasServerDefaultValue(context)) {
     return;
   }
@@ -86,19 +99,13 @@ export const serverDefaultValueProcessSync: ProcessorFnSync<ConditionsScope> = (
     return;
   }
   let defaultValue = null;
-  if (component.defaultValue !== undefined && component.defaultValue !== null) {
+  if (component.defaultValue) {
     defaultValue = component.defaultValue;
     if (component.multiple && !Array.isArray(defaultValue)) {
       defaultValue = defaultValue ? [defaultValue] : [];
     }
-    scope.defaultValues.push({
-      path,
-      value: defaultValue,
-    });
-  }
-  if (defaultValue !== null && defaultValue !== undefined) {
-    set(data, path, defaultValue);
   }
+  setDefaultValue(context, defaultValue);
 };
 
 export const defaultValueProcess: ProcessorFn<ConditionsScope> = async (

src/process/fetch/index.ts

@@ -5,7 +5,6 @@ import {
   FetchScope,
   FetchFn,
   DataSourceComponent,
-  FilterContext,
 } from 'types';
 import { get, set } from 'lodash';
 import { evaluate, interpolate } from 'utils';
@@ -102,8 +101,10 @@ export const fetchProcess: ProcessorFn<FetchScope> = async (context: FetchContex
     );
 
     // Make sure the value does not get filtered for now...
-    if (!(scope as FilterContext).filter) (scope as FilterContext).filter = {};
-    (scope as FilterContext).filter[path] = true;
+    if (!scope.filter) scope.filter = {};
+    if (!(scope as any).clearHidden?.hasOwnProperty(path)) {
+      scope.filter[path] = true;
+    }
     scope.fetched[path] = get(row, key);
   } catch (err: any) {
     console.log(err.message);

src/process/filter/__tests__/filter.test.ts

@@ -1,9 +1,14 @@
 import { expect } from 'chai';
 
-import { filterProcessSync } from '../';
+import { filterProcessSync, filterPostProcess } from '../';
 import { generateProcessorContext } from '../../__tests__/fixtures/util';
 import { FilterScope, ProcessorContext } from 'types';
 
+const filterProcess = async (context: ProcessorContext<FilterScope>) => {
+  filterProcessSync(context);
+  filterPostProcess(context);
+};
+
 describe('Filter processor', function () {
   it('Should not filter empty array value for dataGrid component', async function () {
     const dataGridComp = {
@@ -24,9 +29,9 @@ describe('Filter processor', function () {
       dataGrid: [],
     };
     const context: any = generateProcessorContext(dataGridComp, data);
-    filterProcessSync(context);
+    filterProcess(context);
     expect(context.scope.filter).to.deep.equal({
-      dataGrid: { compModelType: 'nestedArray', include: true, value: [] },
+      dataGrid: true,
     });
   });
 
@@ -48,9 +53,9 @@ describe('Filter processor', function () {
       editGrid: [],
     };
     const context: any = generateProcessorContext(editGridComp, data);
-    filterProcessSync(context);
+    filterProcess(context);
     expect(context.scope.filter).to.deep.equal({
-      editGrid: { compModelType: 'nestedArray', include: true, value: [] },
+      editGrid: true,
     });
   });
 
@@ -73,9 +78,9 @@ describe('Filter processor', function () {
       dataTable: [],
     };
     const context: any = generateProcessorContext(dataTableComp, data);
-    filterProcessSync(context);
+    filterProcess(context);
     expect(context.scope.filter).to.deep.equal({
-      dataTable: { compModelType: 'nestedArray', include: true, value: [] },
+      dataTable: true,
     });
   });
 
@@ -128,32 +133,28 @@ describe('Filter processor', function () {
       ],
     };
     const context: any = generateProcessorContext(tagpadComp, data);
-    filterProcessSync(context);
-    expect(context.scope.filter).to.deep.equal({
-      tagpad: {
-        compModelType: 'nestedDataArray',
-        include: true,
-        value: [
-          {
-            coordinate: {
-              x: 83,
-              y: 61,
-              width: 280,
-              height: 133,
-            },
-            data: {},
+    filterProcess(context);
+    expect(context.scope.filtered).to.deep.equal({
+      tagpad: [
+        {
+          coordinate: {
+            x: 83,
+            y: 61,
+            width: 280,
+            height: 133,
           },
-          {
-            coordinate: {
-              x: 194,
-              y: 93,
-              width: 280,
-              height: 133,
-            },
-            data: {},
+          data: {},
+        },
+        {
+          coordinate: {
+            x: 194,
+            y: 93,
+            width: 280,
+            height: 133,
           },
-        ],
-      },
+          data: {},
+        },
+      ],
     });
   });
 
@@ -184,11 +185,11 @@ describe('Filter processor', function () {
     };
 
     const context: ProcessorContext<FilterScope> = generateProcessorContext(dataMapComp, data);
-    filterProcessSync(context);
-    expect(context.scope.filter).to.deep.equal({
+    filterProcess(context);
+    expect(context.scope.filtered).to.deep.equal({
       dataMap: {
-        compModelType: 'map',
-        include: true,
+        foo: 'bar',
+        baz: 'biz',
       },
     });
   });