From a32d996fa5796b32b0a60ceaf527c9af269546bd Mon Sep 17 00:00:00 2001 From: Vemparala Surya Vamsi Date: Wed, 30 Oct 2024 20:30:45 +0530 Subject: [PATCH 1/5] klona fix --- app/client/src/workers/Evaluation/evalTreeWithChanges.ts | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/app/client/src/workers/Evaluation/evalTreeWithChanges.ts b/app/client/src/workers/Evaluation/evalTreeWithChanges.ts index bc561de0df56..b9797144e04a 100644 --- a/app/client/src/workers/Evaluation/evalTreeWithChanges.ts +++ b/app/client/src/workers/Evaluation/evalTreeWithChanges.ts @@ -16,6 +16,7 @@ import { } from "./helpers"; import type { DataTreeDiff } from "ee/workers/Evaluation/evaluationUtils"; import type DataTreeEvaluator from "workers/common/DataTreeEvaluator"; +import { klona } from "klona/json"; const getDefaultEvalResponse = (): EvalTreeResponseData => ({ updates: "[]", @@ -134,9 +135,10 @@ export const evaluateAndGenerateResponse = ( ); /** Make sure evalMetaUpdates is sanitized to prevent postMessage failure */ - defaultResponse.evalMetaUpdates = JSON.parse( - JSON.stringify([...(metaUpdates || []), ...updateResponse.evalMetaUpdates]), - ); + defaultResponse.evalMetaUpdates = klona([ + ...(metaUpdates || []), + ...updateResponse.evalMetaUpdates, + ]); defaultResponse.staleMetaIds = updateResponse.staleMetaIds; defaultResponse.dependencies = dataTreeEvaluator.inverseDependencies; From c79ba93087f588773288c9da4bc05d756a545b07 Mon Sep 17 00:00:00 2001 From: Vemparala Surya Vamsi Date: Thu, 31 Oct 2024 12:01:36 +0530 Subject: [PATCH 2/5] refactor to one level --- .../src/entities/DataTree/dataTreeFactory.ts | 201 +++++++++--------- app/client/src/selectors/dataTreeSelectors.ts | 164 +++++++++----- 2 files changed, 208 insertions(+), 157 deletions(-) diff --git a/app/client/src/entities/DataTree/dataTreeFactory.ts b/app/client/src/entities/DataTree/dataTreeFactory.ts index 5d68c072be0e..811a27dc7a30 100644 --- a/app/client/src/entities/DataTree/dataTreeFactory.ts +++ b/app/client/src/entities/DataTree/dataTreeFactory.ts @@ -1,88 +1,72 @@ import { generateDataTreeAction } from "ee/entities/DataTree/dataTreeAction"; import { generateDataTreeJSAction } from "ee/entities/DataTree/dataTreeJSAction"; import { generateDataTreeWidget } from "entities/DataTree/dataTreeWidget"; -import log from "loglevel"; +import type { DependencyMap } from "utils/DynamicBindingUtils"; + import { ENTITY_TYPE, EvaluationSubstitutionType, } from "ee/entities/DataTree/types"; import { generateDataTreeModuleInputs } from "ee/entities/DataTree/utils"; -import type { - DataTreeSeed, - AppsmithEntity, - EntityTypeValue, -} from "ee/entities/DataTree/types"; -import type { - unEvalAndConfigTree, - ConfigTree, - UnEvalTree, -} from "entities/DataTree/dataTreeTypes"; +import type { EntityTypeValue } from "ee/entities/DataTree/types"; +import type { ConfigTree, UnEvalTree } from "entities/DataTree/dataTreeTypes"; import { isEmpty } from "lodash"; import { generateModuleInstance } from "ee/entities/DataTree/dataTreeModuleInstance"; -import { - endSpan, - startNestedSpan, - startRootSpan, -} from "UITelemetry/generateTraces"; -export class DataTreeFactory { - static create({ - actions, - appData, - editorConfigs, - isMobile, - jsActions, - layoutSystemType, - loadingEntities, - metaWidgets, - moduleInputs, - moduleInstanceEntities, - moduleInstances, - pluginDependencyConfig, - theme, - widgets, - widgetsMeta, - }: DataTreeSeed): unEvalAndConfigTree { - const dataTree: UnEvalTree = {}; - const configTree: ConfigTree = {}; - const start = performance.now(); - const startActions = performance.now(); - const rootSpan = startRootSpan("DataTreeFactory.create"); - const actionsSpan = startNestedSpan("DataTreeFactory.actions", rootSpan); - - actions.forEach((action) => { - const editorConfig = editorConfigs[action.config.pluginId]; - const dependencyConfig = pluginDependencyConfig[action.config.pluginId]; - const { configEntity, unEvalEntity } = generateDataTreeAction( - action, - editorConfig, - dependencyConfig, - ); +import { endSpan, startRootSpan } from "UITelemetry/generateTraces"; + +import type { LayoutSystemTypes } from "layoutSystems/types"; +import type { CanvasWidgetsReduxState } from "reducers/entityReducers/canvasWidgetsReducer"; +import type { MetaState } from "reducers/entityReducers/metaReducer"; +import type { LoadingEntitiesState } from "reducers/evaluationReducers/loadingEntitiesReducer"; +import type { MetaWidgetsReduxState } from "reducers/entityReducers/metaWidgetsReducer"; +import type { ActionDataState } from "ee/reducers/entityReducers/actionsReducer"; +import type { JSCollectionDataState } from "ee/reducers/entityReducers/jsActionsReducer"; +import type { ModuleInputSection } from "ee/constants/ModuleConstants"; +import type { ModuleInstance } from "ee/constants/ModuleInstanceConstants"; - dataTree[action.config.name] = unEvalEntity; - configTree[action.config.name] = configEntity; - }); - const endActions = performance.now(); +export class DataTreeFactory { + static metaWidgets( + metaWidgets: MetaWidgetsReduxState, + widgetsMeta: MetaState, + loadingEntities: LoadingEntitiesState, + ) { + const widgetsSpan = startRootSpan("DataTreeFactory.metaWidgets"); + + const res = Object.values(metaWidgets).reduce( + (acc, widget) => { + const { configEntity, unEvalEntity } = generateDataTreeWidget( + widget, + widgetsMeta[widget.metaWidgetId || widget.widgetId], + loadingEntities, + ); - endSpan(actionsSpan); + acc.dataTree[widget.widgetName] = unEvalEntity; + acc.configTree[widget.widgetName] = configEntity; - const startJsActions = performance.now(); - const jsActionsSpan = startNestedSpan( - "DataTreeFactory.jsActions", - rootSpan, + return acc; + }, + { dataTree: {} as UnEvalTree, configTree: {} as ConfigTree }, ); - jsActions.forEach((js) => { - const { configEntity, unEvalEntity } = generateDataTreeJSAction(js); + endSpan(widgetsSpan); - dataTree[js.config.name] = unEvalEntity; - configTree[js.config.name] = configEntity; - }); - const endJsActions = performance.now(); + return res; + } - endSpan(jsActionsSpan); + static widgets( + moduleInputs: ModuleInputSection[], + moduleInstances: Record | null, + moduleInstanceEntities: unknown, + widgets: CanvasWidgetsReduxState, + widgetsMeta: MetaState, + loadingEntities: LoadingEntitiesState, + layoutSystemType: LayoutSystemTypes, + isMobile: boolean, + ) { + const widgetsSpan = startRootSpan("DataTreeFactory.widgets"); - const startWidgets = performance.now(); - const widgetsSpan = startNestedSpan("DataTreeFactory.widgets", rootSpan); + const dataTree: UnEvalTree = {}; + const configTree: ConfigTree = {}; if (!isEmpty(moduleInputs)) { const { configEntity, unEvalEntity } = @@ -121,53 +105,62 @@ export class DataTreeFactory { configTree[widget.widgetName] = configEntity; }); - const endWidgets = performance.now(); - endSpan(widgetsSpan); - dataTree.appsmith = { - ...appData, - // combine both persistent and transient state with the transient state - // taking precedence in case the key is the same - store: appData.store, - theme, - } as AppsmithEntity; - (dataTree.appsmith as AppsmithEntity).ENTITY_TYPE = ENTITY_TYPE.APPSMITH; - - const startMetaWidgets = performance.now(); - const metaWidgetsSpan = startNestedSpan( - "DataTreeFactory.metaWidgets", - rootSpan, + return { dataTree, configTree }; + } + + static jsActions(jsActions: JSCollectionDataState) { + const actionsSpan = startRootSpan("DataTreeFactory.jsActions"); + + const res = jsActions.reduce( + (acc, js) => { + const { configEntity, unEvalEntity } = generateDataTreeJSAction(js); + + acc.dataTree[js.config.name] = unEvalEntity; + acc.configTree[js.config.name] = configEntity; + + return acc; + }, + { + dataTree: {} as UnEvalTree, + configTree: {} as ConfigTree, + }, ); - Object.values(metaWidgets).forEach((widget) => { - const { configEntity, unEvalEntity } = generateDataTreeWidget( - widget, - widgetsMeta[widget.metaWidgetId || widget.widgetId], - loadingEntities, - ); + endSpan(actionsSpan); - dataTree[widget.widgetName] = unEvalEntity; - configTree[widget.widgetName] = configEntity; - }); - const endMetaWidgets = performance.now(); + return res; + } - endSpan(metaWidgetsSpan); - endSpan(rootSpan); + public static actions( + actions: ActionDataState, + editorConfigs: Record, + pluginDependencyConfig: Record, + ) { + const actionsSpan = startRootSpan("DataTreeFactory.actions"); + + const res = actions.reduce( + (acc, action) => { + const editorConfig = editorConfigs[action.config.pluginId]; + const dependencyConfig = pluginDependencyConfig[action.config.pluginId]; + const { configEntity, unEvalEntity } = generateDataTreeAction( + action, + editorConfig, + dependencyConfig, + ); - const end = performance.now(); + acc.dataTree[action.config.name] = unEvalEntity; + acc.configTree[action.config.name] = configEntity; - const out = { - total: end - start, - widgets: endWidgets - startWidgets, - actions: endActions - startActions, - jsActions: endJsActions - startJsActions, - metaWidgets: endMetaWidgets - startMetaWidgets, - }; + return acc; + }, + { dataTree: {} as UnEvalTree, configTree: {} as ConfigTree }, + ); - log.debug("### Create unevalTree timing", out); + endSpan(actionsSpan); - return { unEvalTree: dataTree, configTree }; + return res; } } diff --git a/app/client/src/selectors/dataTreeSelectors.ts b/app/client/src/selectors/dataTreeSelectors.ts index 467af24c1a02..bb338aaa5fa5 100644 --- a/app/client/src/selectors/dataTreeSelectors.ts +++ b/app/client/src/selectors/dataTreeSelectors.ts @@ -11,8 +11,12 @@ import { getCurrentModuleActions, getCurrentModuleJSCollections, } from "ee/selectors/entitiesSelector"; -import type { WidgetEntity } from "ee/entities/DataTree/types"; -import type { DataTree } from "entities/DataTree/dataTreeTypes"; +import type { AppsmithEntity, WidgetEntity } from "ee/entities/DataTree/types"; +import type { + ConfigTree, + DataTree, + UnEvalTree, +} from "entities/DataTree/dataTreeTypes"; import { DataTreeFactory } from "entities/DataTree/dataTreeFactory"; import { getIsMobileBreakPoint, @@ -21,7 +25,6 @@ import { getWidgetsMeta, } from "sagas/selectors"; import "url-search-params-polyfill"; -import { getPageList } from "./appViewSelectors"; import type { AppState } from "ee/reducers"; import { getSelectedAppThemeProperties } from "./appThemingSelectors"; import type { LoadingEntitiesState } from "reducers/evaluationReducers/loadingEntitiesReducer"; @@ -35,6 +38,7 @@ import { getCurrentWorkflowActions, getCurrentWorkflowJSActions, } from "ee/selectors/workflowSelectors"; +import { endSpan, startRootSpan } from "UITelemetry/generateTraces"; export const getLoadingEntities = (state: AppState) => state.evaluations.loadingEntities; @@ -55,26 +59,25 @@ const getLayoutSystemPayload = createSelector( }, ); -const getCurrentActionEntities = createSelector( +const getCurrentActionsEntities = createSelector( getCurrentActions, getCurrentModuleActions, getCurrentWorkflowActions, + (actions, moduleActions, workflowActions) => [ + ...actions, + ...moduleActions, + ...workflowActions, + ], +); +const getCurrentJSActionsEntities = createSelector( getCurrentJSCollections, getCurrentModuleJSCollections, getCurrentWorkflowJSActions, - ( - actions, - moduleActions, - workflowActions, - jsActions, - moduleJSActions, - workflowJsActions, - ) => { - return { - actions: [...actions, ...moduleActions, ...workflowActions], - jsActions: [...jsActions, ...moduleJSActions, ...workflowJsActions], - }; - }, + (jsActions, moduleJSActions, workflowJsActions) => [ + ...jsActions, + ...moduleJSActions, + ...workflowJsActions, + ], ); const getModulesData = createSelector( @@ -90,55 +93,110 @@ const getModulesData = createSelector( }, ); -export const getUnevaluatedDataTree = createSelector( - getCurrentActionEntities, - getWidgetsForEval, - getWidgetsMeta, - getPageList, - getAppData, +const getActionsFromUnevaluatedTree = createSelector( + getCurrentActionsEntities, getPluginEditorConfigs, getPluginDependencyConfig, - getSelectedAppThemeProperties, - getMetaWidgets, - getLayoutSystemPayload, - getLoadingEntities, + (actions, editorConfigs, pluginDependencyConfig) => { + const { configTree, dataTree } = DataTreeFactory.actions( + actions, + editorConfigs, + pluginDependencyConfig, + ); + + return { + configTree, + dataTree, + }; + }, +); + +const getJSActionsFromUnevaluatedTree = createSelector( + getCurrentJSActionsEntities, + (jsActions) => { + return DataTreeFactory.jsActions(jsActions); + }, +); +const getWidgetsFromUnevaluatedTree = createSelector( getModulesData, - ( - currentActionEntities, - widgets, - widgetsMeta, - pageListPayload, - appData, - editorConfigs, - pluginDependencyConfig, - selectedAppThemeProperty, - metaWidgets, - layoutSystemPayload, - loadingEntities, - modulesData, - ) => { - const pageList = pageListPayload || []; - - return DataTreeFactory.create({ - ...currentActionEntities, + getWidgetsForEval, + getWidgetsMeta, + getLoadingEntities, + getLayoutSystemPayload, + (moduleData, widgets, widgetsMeta, loadingEntities, layoutSystemPayload) => { + const { moduleInputs, moduleInstanceEntities, moduleInstances } = + moduleData; + const { isMobile, layoutSystemType } = layoutSystemPayload; + + return DataTreeFactory.widgets( + moduleInputs, + moduleInstances, + moduleInstanceEntities, widgets, widgetsMeta, - pageList, - appData, - editorConfigs, - pluginDependencyConfig, - theme: selectedAppThemeProperty, + loadingEntities, + layoutSystemType, + isMobile, + ); + }, +); +const getMetaWidgetsFromUnevaluatedTree = createSelector( + getMetaWidgets, + getWidgetsMeta, + getLoadingEntities, + (metaWidgets, widgetsMeta, loadingEntities) => { + return DataTreeFactory.metaWidgets( metaWidgets, + widgetsMeta, loadingEntities, - ...layoutSystemPayload, - ...modulesData, - }); + ); }, ); export const getEvaluationInverseDependencyMap = (state: AppState) => state.evaluations.dependencies.inverseDependencyMap; +export const getUnevaluatedDataTree = createSelector( + getActionsFromUnevaluatedTree, + getJSActionsFromUnevaluatedTree, + getWidgetsFromUnevaluatedTree, + getAppData, + getSelectedAppThemeProperties, + getMetaWidgetsFromUnevaluatedTree, + (actions, jsActions, widgets, appData, theme, metaWidgets) => { + let dataTree: UnEvalTree = {}; + let configTree: ConfigTree = {}; + const rootSpan = startRootSpan("DataTreeFactory.create"); + + configTree = { + ...actions.configTree, + ...jsActions.configTree, + ...widgets.configTree, + }; + dataTree = { + ...actions.dataTree, + ...jsActions.dataTree, + ...widgets.dataTree, + }; + + dataTree.appsmith = { + ...appData, + // combine both persistent and transient state with the transient state + // taking precedence in case the key is the same + store: appData.store, + theme, + } as AppsmithEntity; + configTree = { ...configTree, ...metaWidgets.configTree }; + dataTree = { ...dataTree, ...metaWidgets.dataTree }; + + endSpan(rootSpan); + + return { + configTree, + unEvalTree: dataTree, + }; + }, +); export const getIsWidgetLoading = createSelector( [getLoadingEntities, (_state: AppState, widgetName: string) => widgetName], (loadingEntities: LoadingEntitiesState, widgetName: string) => From 36750a0741ffe9def6325d3b31b1ea093983ba63 Mon Sep 17 00:00:00 2001 From: Vemparala Surya Vamsi Date: Thu, 31 Oct 2024 17:08:11 +0530 Subject: [PATCH 3/5] refactored generateDataTree widget made it more cache resilient --- .../src/entities/DataTree/dataTreeFactory.ts | 53 ++++++++++++------- .../src/entities/DataTree/dataTreeWidget.ts | 9 +++- app/client/src/entities/Widget/utils.ts | 1 + .../loadingEntitiesReducer.ts | 12 ++++- app/client/src/selectors/dataTreeSelectors.ts | 34 ++++++++---- 5 files changed, 79 insertions(+), 30 deletions(-) diff --git a/app/client/src/entities/DataTree/dataTreeFactory.ts b/app/client/src/entities/DataTree/dataTreeFactory.ts index 811a27dc7a30..c764177d437a 100644 --- a/app/client/src/entities/DataTree/dataTreeFactory.ts +++ b/app/client/src/entities/DataTree/dataTreeFactory.ts @@ -54,9 +54,6 @@ export class DataTreeFactory { } static widgets( - moduleInputs: ModuleInputSection[], - moduleInstances: Record | null, - moduleInstanceEntities: unknown, widgets: CanvasWidgetsReduxState, widgetsMeta: MetaState, loadingEntities: LoadingEntitiesState, @@ -68,6 +65,36 @@ export class DataTreeFactory { const dataTree: UnEvalTree = {}; const configTree: ConfigTree = {}; + Object.values(widgets).forEach((widget) => { + const { configEntity, unEvalEntity } = generateDataTreeWidget( + widget, + widgetsMeta[widget.metaWidgetId || widget.widgetId], + loadingEntities, + layoutSystemType, + isMobile, + ); + + dataTree[widget.widgetName] = unEvalEntity; + configTree[widget.widgetName] = configEntity; + }); + + endSpan(widgetsSpan); + + return { dataTree, configTree }; + } + + public static moduleComponents( + moduleInputs: ModuleInputSection[], + moduleInstances: Record | null, + moduleInstanceEntities: unknown, + ) { + const moduleComponentsSpan = startRootSpan( + "DataTreeFactory.moduleComponents", + ); + + const dataTree: UnEvalTree = {}; + const configTree: ConfigTree = {}; + if (!isEmpty(moduleInputs)) { const { configEntity, unEvalEntity } = generateDataTreeModuleInputs(moduleInputs); @@ -92,22 +119,12 @@ export class DataTreeFactory { }); } - Object.values(widgets).forEach((widget) => { - const { configEntity, unEvalEntity } = generateDataTreeWidget( - widget, - widgetsMeta[widget.metaWidgetId || widget.widgetId], - loadingEntities, - layoutSystemType, - isMobile, - ); - - dataTree[widget.widgetName] = unEvalEntity; - configTree[widget.widgetName] = configEntity; - }); + endSpan(moduleComponentsSpan); - endSpan(widgetsSpan); - - return { dataTree, configTree }; + return { + dataTree, + configTree, + }; } static jsActions(jsActions: JSCollectionDataState) { diff --git a/app/client/src/entities/DataTree/dataTreeWidget.ts b/app/client/src/entities/DataTree/dataTreeWidget.ts index a5a9a2fd8c8b..51d99a57f6ba 100644 --- a/app/client/src/entities/DataTree/dataTreeWidget.ts +++ b/app/client/src/entities/DataTree/dataTreeWidget.ts @@ -1,5 +1,5 @@ import { getAllPathsFromPropertyConfig } from "entities/Widget/utils"; -import _, { get, isEmpty } from "lodash"; +import _, { get, isEmpty, omit } from "lodash"; import memoize from "micro-memoize"; import type { FlattenedWidgetProps } from "reducers/entityReducers/canvasWidgetsReducer"; import type { DynamicPath } from "utils/DynamicBindingUtils"; @@ -21,6 +21,7 @@ import WidgetFactory from "WidgetProvider/factory"; import { getComponentDimensions } from "layoutSystems/common/utils/ComponentSizeUtils"; import type { LoadingEntitiesState } from "reducers/evaluationReducers/loadingEntitiesReducer"; import { LayoutSystemTypes } from "layoutSystems/types"; +import { WIDGET_PROPS_TO_SKIP_FROM_EVAL } from "constants/WidgetConstants"; /** * @@ -176,13 +177,17 @@ export function getSetterConfig( // Widget changes only when dynamicBindingPathList changes. // Only meta properties change very often, for example typing in an input or selecting a table row. const generateDataTreeWidgetWithoutMeta = ( - widget: FlattenedWidgetProps, + pureWidget: FlattenedWidgetProps, ): { dataTreeWidgetWithoutMetaProps: WidgetEntity; overridingMetaPropsMap: Record; defaultMetaProps: Record; entityConfig: WidgetEntityConfig; } => { + const widget = omit( + pureWidget, + Object.keys(WIDGET_PROPS_TO_SKIP_FROM_EVAL), + ) as FlattenedWidgetProps; // TODO: Fix this the next time the file is edited // eslint-disable-next-line @typescript-eslint/no-explicit-any const derivedProps: any = {}; diff --git a/app/client/src/entities/Widget/utils.ts b/app/client/src/entities/Widget/utils.ts index 475e070f0bb4..f48f18aae533 100644 --- a/app/client/src/entities/Widget/utils.ts +++ b/app/client/src/entities/Widget/utils.ts @@ -367,6 +367,7 @@ const getAllPathsFromPropertyConfigWithoutMemo = ( export const getAllPathsFromPropertyConfig = memoize( getAllPathsFromPropertyConfigWithoutMemo, + { maxSize: 1000 }, ); diff --git a/app/client/src/reducers/evaluationReducers/loadingEntitiesReducer.ts b/app/client/src/reducers/evaluationReducers/loadingEntitiesReducer.ts index 9a22376cbdfa..05e6da8aea0b 100644 --- a/app/client/src/reducers/evaluationReducers/loadingEntitiesReducer.ts +++ b/app/client/src/reducers/evaluationReducers/loadingEntitiesReducer.ts @@ -1,6 +1,7 @@ import { createReducer } from "utils/ReducerUtils"; import type { ReduxAction } from "ee/constants/ReduxActionConstants"; import { ReduxActionTypes } from "ee/constants/ReduxActionConstants"; +import { isEqual } from "lodash"; export type LoadingEntitiesState = Set; @@ -10,7 +11,16 @@ const loadingEntitiesReducer = createReducer(initialState, { [ReduxActionTypes.SET_LOADING_ENTITIES]: ( state: LoadingEntitiesState, action: ReduxAction>, - ): LoadingEntitiesState => action.payload, + ): LoadingEntitiesState => { + const newLoadingEntities = action.payload; + + // its just a set with string properties time complexity of equal is not too bad + if (isEqual(state, newLoadingEntities)) { + return state; + } + + return newLoadingEntities; + }, [ReduxActionTypes.FETCH_PAGE_INIT]: () => initialState, }); diff --git a/app/client/src/selectors/dataTreeSelectors.ts b/app/client/src/selectors/dataTreeSelectors.ts index bb338aaa5fa5..a99f0776272e 100644 --- a/app/client/src/selectors/dataTreeSelectors.ts +++ b/app/client/src/selectors/dataTreeSelectors.ts @@ -21,7 +21,7 @@ import { DataTreeFactory } from "entities/DataTree/dataTreeFactory"; import { getIsMobileBreakPoint, getMetaWidgets, - getWidgetsForEval, + getWidgets, getWidgetsMeta, } from "sagas/selectors"; import "url-search-params-polyfill"; @@ -117,27 +117,43 @@ const getJSActionsFromUnevaluatedTree = createSelector( return DataTreeFactory.jsActions(jsActions); }, ); -const getWidgetsFromUnevaluatedTree = createSelector( + +const getModuleComponentsFromUnEvaluatedTree = createSelector( getModulesData, - getWidgetsForEval, - getWidgetsMeta, - getLoadingEntities, - getLayoutSystemPayload, - (moduleData, widgets, widgetsMeta, loadingEntities, layoutSystemPayload) => { + + (moduleData) => { const { moduleInputs, moduleInstanceEntities, moduleInstances } = moduleData; - const { isMobile, layoutSystemType } = layoutSystemPayload; - return DataTreeFactory.widgets( + return DataTreeFactory.moduleComponents( moduleInputs, moduleInstances, moduleInstanceEntities, + ); + }, +); + +const getWidgetsFromUnevaluatedTree = createSelector( + getModuleComponentsFromUnEvaluatedTree, + getWidgets, + getWidgetsMeta, + getLoadingEntities, + getLayoutSystemPayload, + (moduleData, widgets, widgetsMeta, loadingEntities, layoutSystemPayload) => { + const { isMobile, layoutSystemType } = layoutSystemPayload; + + const widgetsDataTree = DataTreeFactory.widgets( widgets, widgetsMeta, loadingEntities, layoutSystemType, isMobile, ); + + return { + configTree: { ...moduleData.configTree, ...widgetsDataTree.configTree }, + dataTree: { ...moduleData.dataTree, ...widgetsDataTree.dataTree }, + }; }, ); const getMetaWidgetsFromUnevaluatedTree = createSelector( From d4466eddadff647605c34a8e90938aeca308c58c Mon Sep 17 00:00:00 2001 From: Vemparala Surya Vamsi Date: Thu, 31 Oct 2024 17:09:00 +0530 Subject: [PATCH 4/5] Revert "klona fix" This reverts commit a32d996fa5796b32b0a60ceaf527c9af269546bd. --- app/client/src/workers/Evaluation/evalTreeWithChanges.ts | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/app/client/src/workers/Evaluation/evalTreeWithChanges.ts b/app/client/src/workers/Evaluation/evalTreeWithChanges.ts index b9797144e04a..bc561de0df56 100644 --- a/app/client/src/workers/Evaluation/evalTreeWithChanges.ts +++ b/app/client/src/workers/Evaluation/evalTreeWithChanges.ts @@ -16,7 +16,6 @@ import { } from "./helpers"; import type { DataTreeDiff } from "ee/workers/Evaluation/evaluationUtils"; import type DataTreeEvaluator from "workers/common/DataTreeEvaluator"; -import { klona } from "klona/json"; const getDefaultEvalResponse = (): EvalTreeResponseData => ({ updates: "[]", @@ -135,10 +134,9 @@ export const evaluateAndGenerateResponse = ( ); /** Make sure evalMetaUpdates is sanitized to prevent postMessage failure */ - defaultResponse.evalMetaUpdates = klona([ - ...(metaUpdates || []), - ...updateResponse.evalMetaUpdates, - ]); + defaultResponse.evalMetaUpdates = JSON.parse( + JSON.stringify([...(metaUpdates || []), ...updateResponse.evalMetaUpdates]), + ); defaultResponse.staleMetaIds = updateResponse.staleMetaIds; defaultResponse.dependencies = dataTreeEvaluator.inverseDependencies; From a247e1f33bac9b0db146944f965fb50df9bc60f8 Mon Sep 17 00:00:00 2001 From: Vemparala Surya Vamsi Date: Thu, 31 Oct 2024 17:43:27 +0530 Subject: [PATCH 5/5] test case fix --- app/client/src/entities/DataTree/dataTreeWidget.test.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/app/client/src/entities/DataTree/dataTreeWidget.test.ts b/app/client/src/entities/DataTree/dataTreeWidget.test.ts index f50444e11a03..36d78901d407 100644 --- a/app/client/src/entities/DataTree/dataTreeWidget.test.ts +++ b/app/client/src/entities/DataTree/dataTreeWidget.test.ts @@ -225,8 +225,6 @@ describe("generateDataTreeWidget", () => { parentColumnSpace: 0, parentRowSpace: 0, rightColumn: 0, - renderMode: RenderModes.CANVAS, - version: 0, topRow: 0, widgetId: "123", widgetName: "Input1",