{"version":3,"file":"static/js/evalWorker.47c252f2.chunk.js","mappings":"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EAAYE,IAAIz1B,MAAM01B,OACtCQ,aAAcX,EAAYE,IAAI11B,IAAI21B,SAItC,IAAI52B,EAAAA,EAAAA,IAAwBvB,EAAK7P,OAAQ,CACvC,MAAMiT,GAASrB,EAAAA,EAAAA,IAA4B/B,EAAK7P,OAAO,EAAM0R,GAE7DH,EAAW,IACNA,EACHzT,UAAW,IAAImV,GACfqE,cAAezH,EAAK7P,MAAMxB,MAE9B,CAEAipC,EAAuB7+B,IAAI2I,EAAS,IAG/B,CAAEyJ,aAAc,IAAIysB,GAAyBxsB,SAAS,EAAM,C,gDC5IrE,MAwGA,EAxGsB,CACpB,OACA,gBACA,UACA,cACA,YACA,WACA,mBACA,eACA,UACA,QACA,cACA,UACA,oBACA,kBACA,mBACA,gBACA,kBACA,kBACA,oBACA,oBACA,cACA,mBACA,kBACA,sBACA,qBACA,uBACA,iBACA,cACA,mBACA,sBACA,kBACA,kBACA,mBACA,sBACA,gBACA,kBACA,qBACA,kBACA,oBACA,mBACA,mBACA,gBACA,mBACA,oBACA,kBACA,iBACA,qBACA,mBACA,kBACA,kBACA,mBACA,iBACA,mBACA,oBACA,sBACA,oBACA,oBACA,uBACA,mBACA,qBACA,iBACA,sBACA,mBACA,oBACA,oBACA,kBACA,oBACA,kBACA,mBACA,0BACA,uBACA,mBACA,sBACA,sBACA,sBACA,kBACA,mBACA,mBACA,mBACA,qBACA,mBACA,aACA,OACA,aACA,WACA,aACA,aACA,OACA,qBACA,YACA,YACA,UAG6Brb,QAC7B,CAACC,EAAKkC,KACJlC,EAAIkC,IAAO,EAEJlC,IAET,CAAC,E,gDCpEI,IAAK6N,EAAQ,SAARA,GAUV,OAVUA,EAAQ,YAARA,EAAQ,kBAARA,EAAQ,cAARA,CAAQ,K,oJCqHb,MAGMwsB,EAAsB,kBACtBrjB,EAAkC,6BAClCC,EAAsB,UAahC2xB,EAAAA,GAAWC,IAAMC,EAAAA,EACjBF,EAAAA,GAAWG,GAAKC,EAAAA,EAChBJ,EAAAA,GAAWK,KAAOC,EAAAA,EAClBN,EAAAA,GAAWO,OAASD,EAAAA,EACpBN,EAAAA,GAAWQ,G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","sources":["../packages/ast/src/utils.ts","ce/workers/Evaluation/getEntityForEvalContextMap.ts","workers/Evaluation/getEntityForContext.ts","ce/workers/Evaluation/Actions.ts","instrumentation/generateWebWorkerTraces.ts","workers/common/JSLibrary/index.ts","utils/DynamicBindingUtils.ts","workers/Evaluation/handlers/workerEnv.ts","workers/Evaluation/fns/utils/fnGuard.ts","workers/Evaluation/JSObject/utils.ts","workers/common/DependencyMap/utils.ts","workers/Evaluation/evaluate.ts","../packages/utils/src/object/keys.ts","utils/TypeHelpers.ts","../packages/ast/src/index.ts","entities/Replay/replayUtils.ts","workers/common/DataTreeEvaluator/utils.ts","workers/common/DataTreeEvaluator/validationUtils.ts","ce/workers/Evaluation/evalWorkerActions.ts","ce/workers/Evaluation/generateOverrideContext.ts","ee/workers/Evaluation/generateOverrideContext.ts","workers/Evaluation/JSObject/index.ts","workers/Evaluation/fns/overrides/interval.ts","ee/entities/Engine/actionHelpers.ts","entities/Replay/ReplayEntity/ReplayCanvas.ts","workers/Evaluation/evaluationSubstitution.ts","ce/workers/common/DependencyMap/utils/getEntityDependenciesByType.ts","workers/common/DependencyMap/utils/getEntityDependencies.ts","entities/DependencyMap/DependencyMapUtils.ts","workers/common/AppComputationCache/types.ts","workers/common/AppComputationCache/index.ts","workers/common/DependencyMap/index.ts","workers/Evaluation/dataStore/utils.ts","workers/common/DataTreeEvaluator/index.ts","workers/Evaluation/JSObject/JSVariableEvents.ts","workers/Evaluation/handlers/evalTree.ts","workers/Evaluation/formEval.ts","constants/BindingsConstants.ts","workers/common/JSLibrary/lodash-wrapper.js","workers/Evaluation/setters.ts","workers/Evaluation/evalTreeWithChanges.ts","../packages/ast/src/jsObject/index.ts","workers/Evaluation/domApis.ts","entities/AppsmithConsole/index.ts","constants/AppsmithActionConstants/ActionConstants.tsx","ce/entities/DataTree/types.ts","ee/entities/DataTree/types.ts","workers/Evaluation/fns/index.ts","workers/Evaluation/JSObject/Collection.ts","workers/Evaluation/errorModifier.ts","utils/MessageUtil.ts","ce/workers/Evaluation/evaluationUtils.ts","workers/Evaluation/dataStore/index.ts","components/formControls/utils.ts","components/editorComponents/ActionCreator/constants.ts","ce/constants/routes/appRoutes.ts","entities/DependencyMap/index.ts","workers/common/JSLibrary/resetJSLibraries.ts","workers/common/JSLibrary/ternDefinitionGenerator.ts","workers/Evaluation/handlers/jsLibrary.ts","entities/Replay/ReplayEntity/ReplayEditor.ts","workers/Evaluation/fns/overrides/timeout.ts","workers/Evaluation/fns/overrides/fetch.ts","workers/Evaluation/fns/overrides/localStorage.ts","workers/Evaluation/fns/overrides/index.ts","workers/Evaluation/handlers/index.ts","workers/Evaluation/handlers/evalActionBindings.ts","workers/Evaluation/handlers/replay.ts","workers/Evaluation/handlers/validateProperty.ts","workers/Evaluation/handlers/setupEvalEnv.ts","workers/Evaluation/SetupDOM.ts","workers/Evaluation/handlers/initFormEval.ts","workers/Evaluation/handlers/evalTrigger.ts","workers/Evaluation/handlers/evalExpression.ts","workers/Evaluation/evaluation.worker.ts","workers/Evaluation/JSObject/jsPropertiesState.ts","workers/Evaluation/helpers.ts","ce/entities/DataTree/utils.ts","workers/Evaluation/fns/overrides/console.ts","../packages/ast/src/constants/ast.ts","workers/Evaluation/handlers/updateActionData.ts","../webpack/bootstrap","../webpack/runtime/amd options","../webpack/runtime/chunk loaded","../webpack/runtime/compat get default export","../webpack/runtime/create fake namespace object","../webpack/runtime/define property getters","../webpack/runtime/ensure chunk","../webpack/runtime/get javascript chunk filename","../webpack/runtime/get mini-css chunk filename","../webpack/runtime/global","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/make namespace object","../webpack/runtime/node module decorator","../webpack/runtime/runtimeId","../webpack/runtime/publicPath","../webpack/runtime/compat","../webpack/runtime/importScripts chunk loading","../webpack/runtime/nonce","../webpack/runtime/startup chunk dependencies","../webpack/startup"],"sourcesContent":["import unescapeJS from \"unescape-js\";\nimport type { PropertyNode } from \"../index\";\nimport { isLiteralNode } from \"../index\";\n\nconst beginsWithLineBreakRegex = /^\\s+|\\s+$/;\n\nexport function sanitizeScript(js: string, evaluationVersion: number) {\n  // We remove any line breaks from the beginning of the script because that\n  // makes the final function invalid. We also unescape any escaped characters\n  // so that eval can happen\n  //default value of evalutaion version is 2\n  evaluationVersion = evaluationVersion ? evaluationVersion : 2;\n  const trimmedJS = js.replace(beginsWithLineBreakRegex, \"\");\n\n  return evaluationVersion > 1 ? trimmedJS : unescapeJS(trimmedJS);\n}\n\n// For the times when you need to know if something truly an object like { a: 1, b: 2}\n// typeof, lodash.isObject and others will return false positives for things like array, null, etc\nexport const isTrueObject = (\n  item: unknown,\n): item is Record<string, unknown> => {\n  return Object.prototype.toString.call(item) === \"[object Object]\";\n};\n\nexport const getNameFromPropertyNode = (node: PropertyNode): string =>\n  isLiteralNode(node.key) ? String(node.key.value) : node.key.name;\n\ninterface Position {\n  line: number;\n  ch: number;\n}\n\nexport const extractContentByPosition = (\n  content: string,\n  position: { from: Position; to: Position },\n) => {\n  const eachLine = content.split(\"\\n\");\n\n  let returnedString = \"\";\n\n  for (let i = position.from.line; i <= position.to.line; i++) {\n    if (i === position.from.line) {\n      returnedString =\n        position.from.line !== position.to.line\n          ? eachLine[position.from.line].slice(position.from.ch)\n          : eachLine[position.from.line].slice(\n              position.from.ch,\n              position.to.ch + 1,\n            );\n    } else if (i === position.to.line) {\n      returnedString += eachLine[position.to.line].slice(0, position.to.ch + 1);\n    } else {\n      returnedString += eachLine[i];\n    }\n\n    if (i !== position.to.line) {\n      returnedString += \"\\n\";\n    }\n  }\n\n  return returnedString;\n};\n\nexport const getStringValue = (\n  inputValue: string | number | boolean | RegExp,\n) => {\n  if (typeof inputValue === \"object\" || typeof inputValue === \"boolean\") {\n    inputValue = JSON.stringify(inputValue);\n  } else if (typeof inputValue === \"number\" || typeof inputValue === \"string\") {\n    inputValue += \"\";\n  }\n\n  return inputValue;\n};\n","import { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { getJSActionForEvalContext } from \"ee/workers/Evaluation/getJSActionForEvalContext\";\n\nexport const getEntityForEvalContextMap: Record<\n  string,\n  (entityName: string, entity: DataTreeEntity) => unknown\n> = {\n  [ENTITY_TYPE.JSACTION]: (entityName, entity) => {\n    return getJSActionForEvalContext(entityName, entity);\n  },\n};\n","import { getEntityForEvalContextMap } from \"ee/workers/Evaluation/getEntityForEvalContextMap\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\n\nexport function getEntityForEvalContext(\n  entity: DataTreeEntity,\n  entityName: string,\n) {\n  const getterMethod = getEntityForEvalContextMap[entity.ENTITY_TYPE];\n\n  if (!getterMethod) return entity;\n\n  return getterMethod(entityName, entity);\n}\n","/* eslint-disable @typescript-eslint/ban-types */\n\nimport set from \"lodash/set\";\nimport type { DataTreeEntityConfig } from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type { EvalContext } from \"workers/Evaluation/evaluate\";\nimport type { EvaluationVersion } from \"constants/EvalConstants\";\nimport { addFn } from \"workers/Evaluation/fns/utils/fnGuard\";\nimport {\n  getEntityFunctions,\n  getPlatformFunctions,\n} from \"ee/workers/Evaluation/fns\";\nimport { getEntityForEvalContext } from \"workers/Evaluation/getEntityForContext\";\nimport { klona } from \"klona/full\";\nimport { isEmpty } from \"lodash\";\nimport setters from \"workers/Evaluation/setters\";\ndeclare global {\n  /** All identifiers added to the worker global scope should also\n   * be included in the DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS in\n   * app/client/src/constants/WidgetValidation.ts\n   * */\n\n  interface Window {\n    $isDataField: boolean;\n    $isAsync: boolean;\n    $evaluationVersion: EvaluationVersion;\n    $cloudHosting: boolean;\n  }\n}\n\nexport enum ExecutionType {\n  PROMISE = \"PROMISE\",\n  TRIGGER = \"TRIGGER\",\n}\n\n/**\n * This method returns new dataTree with entity function and platform function\n */\nexport const getDataTreeContext = (args: {\n  dataTree: Readonly<DataTree>;\n  removeEntityFunctions?: boolean;\n  isTriggerBased: boolean;\n  configTree: ConfigTree;\n}) => {\n  const {\n    configTree,\n    dataTree,\n    isTriggerBased,\n    removeEntityFunctions = false,\n  } = args;\n  const EVAL_CONTEXT: EvalContext = {};\n\n  const dataTreeEntries = Object.entries(dataTree);\n  const entityFunctionCollection: Record<string, Record<string, Function>> = {};\n\n  if (isTriggerBased && !removeEntityFunctions) setters.clear();\n\n  for (const [entityName, entity] of dataTreeEntries) {\n    EVAL_CONTEXT[entityName] = getEntityForEvalContext(entity, entityName);\n\n    // when we evaluate data field and removeEntityFunctions is true then we skip adding entity function to evalContext\n    const skipEntityFunctions = !removeEntityFunctions && !isTriggerBased;\n\n    if (skipEntityFunctions) continue;\n\n    for (const entityFn of getEntityFunctions()) {\n      if (!entityFn.qualifier(entity)) continue;\n\n      const func = entityFn.fn(entity, entityName);\n      const fullPath = `${entityFn.path || `${entityName}.${entityFn.name}`}`;\n\n      set(entityFunctionCollection, fullPath, func);\n    }\n\n    // Don't add entity function ( setter method ) to evalContext if removeEntityFunctions is true\n    if (removeEntityFunctions) continue;\n\n    const entityConfig = configTree[entityName];\n    const entityMethodMap = setters.getEntitySettersFromConfig(\n      entityConfig,\n      entityName,\n      entity,\n    );\n\n    if (isEmpty(entityMethodMap)) continue;\n\n    EVAL_CONTEXT[entityName] = Object.assign(\n      {},\n      dataTree[entityName],\n      entityMethodMap,\n    );\n  }\n\n  if (removeEntityFunctions) {\n    removeEntityFunctionsFromEvalContext(\n      entityFunctionCollection,\n      EVAL_CONTEXT,\n    );\n\n    return EVAL_CONTEXT;\n  }\n\n  if (!isTriggerBased) {\n    return EVAL_CONTEXT;\n  }\n\n  // if eval is not trigger based i.e., sync eval then we skip adding entity function to evalContext\n  addEntityFunctionsToEvalContext(EVAL_CONTEXT, entityFunctionCollection);\n\n  return EVAL_CONTEXT;\n};\n\nexport const addEntityFunctionsToEvalContext = (\n  evalContext: EvalContext,\n  entityFunctionCollection: Record<string, Record<string, Function>>,\n) => {\n  for (const [entityName, funcObj] of Object.entries(\n    entityFunctionCollection,\n  )) {\n    evalContext[entityName] = Object.assign(\n      {},\n      evalContext[entityName],\n      funcObj,\n    );\n  }\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const addPlatformFunctionsToEvalContext = (context: any) => {\n  for (const fnDef of getPlatformFunctions()) {\n    addFn(context, fnDef.name, fnDef.fn.bind(context));\n  }\n};\n\nexport function getAllSetterFunctions(\n  dataTree: DataTree,\n  configTree: ConfigTree,\n) {\n  const entitiesSetterFunctions: Record<string, true> = {};\n  const dataTreeEntries = Object.entries(dataTree);\n\n  for (const [entityName, entity] of dataTreeEntries) {\n    const entityConfig = configTree[entityName];\n    const entityMethodMap = setters.getEntitySettersFromConfig(\n      entityConfig,\n      entityName,\n      entity,\n    );\n\n    if (isEmpty(entityMethodMap)) continue;\n\n    for (const methodName of Object.keys(entityMethodMap)) {\n      entitiesSetterFunctions[`${entityName}.${methodName}`] = true;\n    }\n  }\n\n  return entitiesSetterFunctions;\n}\n\nexport function getEntitySetterFunctions(\n  entityConfig: DataTreeEntityConfig,\n  entityName: string,\n  entity: DataTreeEntity,\n) {\n  const entitySetterFunctions: Record<string, true> = {};\n  const entityMethodMap = setters.getEntitySettersFromConfig(\n    entityConfig,\n    entityName,\n    entity,\n  );\n\n  for (const methodName of Object.keys(entityMethodMap)) {\n    entitySetterFunctions[`${entityName}.${methodName}`] = true;\n  }\n\n  return entitySetterFunctions;\n}\n\nexport const getAllAsyncFunctions = (\n  dataTree: DataTree,\n  configTree: ConfigTree,\n) => {\n  let allAsyncFunctions: Record<string, true> = {};\n  const dataTreeEntries = Object.entries(dataTree);\n\n  for (const [entityName, entity] of dataTreeEntries) {\n    for (const entityFn of getEntityFunctions()) {\n      if (!entityFn.qualifier(entity)) continue;\n\n      const fullPath = `${entityFn.path || `${entityName}.${entityFn.name}`}`;\n\n      allAsyncFunctions[fullPath] = true;\n    }\n  }\n\n  const setterMethods = getAllSetterFunctions(dataTree, configTree);\n\n  allAsyncFunctions = { ...allAsyncFunctions, ...setterMethods };\n\n  for (const platformFn of getPlatformFunctions()) {\n    allAsyncFunctions[platformFn.name] = true;\n  }\n\n  return allAsyncFunctions;\n};\n\nexport const removeEntityFunctionsFromEvalContext = (\n  entityFunctionCollection: Record<string, Record<string, Function>>,\n  evalContext: EvalContext,\n) => {\n  for (const [entityName, funcObj] of Object.entries(\n    entityFunctionCollection,\n  )) {\n    const entity = klona(evalContext[entityName]);\n\n    Object.keys(funcObj).forEach((entityFn) => {\n      delete entity[entityFn];\n    });\n    evalContext[entityName] = entity;\n  }\n};\n","import type { WebworkerSpanData, Attributes } from \"./types\";\n\n//this is used in webworkers to generate telemetry data\n//this telemetry data is pushed to the main thread which is converted\n//to regular otlp telemetry data and subsequently exported to our telemetry collector\nexport const newWebWorkerSpanData = (\n  spanName: string,\n  attributes: Attributes = {},\n): WebworkerSpanData => {\n  return {\n    attributes,\n    spanName,\n    startTime: Date.now(),\n    endTime: Date.now(),\n  };\n};\n\nconst addEndTimeForWebWorkerSpanData = (span: WebworkerSpanData) => {\n  span.endTime = Date.now();\n};\n\nexport const profileAsyncFn = async <T>(\n  spanName: string,\n  fn: () => Promise<T>,\n  allSpans: Record<string, WebworkerSpanData | Attributes>,\n  attributes: Attributes = {},\n) => {\n  const span = newWebWorkerSpanData(spanName, attributes);\n  const res: T = await fn();\n\n  addEndTimeForWebWorkerSpanData(span);\n  allSpans[spanName] = span;\n\n  return res;\n};\n\nexport const profileFn = <T>(\n  spanName: string,\n  attributes: Attributes = {},\n  allSpans: Record<string, WebworkerSpanData | Attributes>,\n  fn: () => T,\n) => {\n  const span = newWebWorkerSpanData(spanName, attributes);\n  const res: T = fn();\n\n  addEndTimeForWebWorkerSpanData(span);\n  allSpans[spanName] = span;\n\n  return res;\n};\n\nexport const filterSpanData = (\n  spanData: Record<string, WebworkerSpanData | Attributes>,\n): Record<string, WebworkerSpanData> => {\n  return Object.keys(spanData)\n    .filter((key) => !key.startsWith(\"__\"))\n    .reduce<Record<string, WebworkerSpanData>>((obj, key) => {\n      obj[key] = spanData[key] as WebworkerSpanData;\n\n      return obj;\n    }, {});\n};\n","import lodashPackageJson from \"lodash/package.json\";\nimport momentPackageJson from \"moment-timezone/package.json\";\n\nexport interface JSLibrary {\n  version?: string;\n  docsURL: string;\n  name: string;\n  accessor: string[];\n  url?: string;\n  id?: string;\n}\n\nexport const defaultLibraries: JSLibrary[] = [\n  {\n    accessor: [\"_\"],\n    version: lodashPackageJson.version,\n    docsURL: `https://lodash.com/docs/${lodashPackageJson.version}`,\n    name: \"lodash\",\n  },\n  {\n    accessor: [\"moment\"],\n    version: momentPackageJson.version,\n    docsURL: `https://momentjs.com/docs/`,\n    name: \"moment\",\n  },\n  {\n    accessor: [\"forge\"],\n    version: \"1.3.0\",\n    docsURL: \"https://github.com/digitalbazaar/forge\",\n    name: \"forge\",\n  },\n];\n\nexport const JSLibraries = [...defaultLibraries];\n\nconst JSLibraryAccessorModifier = () => {\n  let jsLibraryAccessorSet = new Set(\n    JSLibraries.flatMap((lib) => lib.accessor),\n  );\n\n  return {\n    regenerateSet: () => {\n      jsLibraryAccessorSet = new Set(\n        JSLibraries.flatMap((lib) => lib.accessor),\n      );\n\n      return;\n    },\n    getSet: () => {\n      return jsLibraryAccessorSet;\n    },\n  };\n};\n\nexport const JSLibraryAccessor = JSLibraryAccessorModifier();\n\nexport const libraryReservedIdentifiers = defaultLibraries.reduce(\n  (acc, lib) => {\n    lib.accessor.forEach((a) => (acc[a] = true));\n\n    return acc;\n  },\n  {} as Record<string, boolean>,\n);\n","import _, { get, isString } from \"lodash\";\nimport { DATA_BIND_REGEX } from \"constants/BindingsConstants\";\nimport type { Action } from \"entities/Action\";\nimport type { WidgetProps } from \"widgets/BaseWidget\";\nimport type { Severity } from \"entities/AppsmithConsole\";\nimport {\n  getEntityNameAndPropertyPath,\n  isAction,\n  isJSAction,\n  isTrueObject,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { DataTreeEntityConfig } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { getType, Types } from \"./TypeHelpers\";\nimport { ViewTypes } from \"components/formControls/utils\";\n\nexport type DependencyMap = Record<string, Array<string>>;\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FormEditorConfigs = Record<string, any[]>;\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FormSettingsConfigs = Record<string, any[]>;\nexport type FormDependencyConfigs = Record<string, DependencyMap>;\nexport type FormDatasourceButtonConfigs = Record<string, string[]>;\n\nfunction hasNonStringSemicolons(stringifiedJS: string) {\n  // This regex pattern matches semicolons that are not inside single or double quotes\n  const regex = /;(?=(?:[^']*'[^']*')*[^']*$)(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/g;\n\n  return regex.test(stringifiedJS);\n}\n\n// referencing DATA_BIND_REGEX fails for the value \"{{Table1.tableData[Table1.selectedRowIndex]}}\" if you run it multiple times and don't recreate\nexport const isDynamicValue = (value: string): boolean =>\n  DATA_BIND_REGEX.test(value);\n\n//{{}}{{}}}\nexport function getDynamicStringSegments(dynamicString: string): string[] {\n  let stringSegments = [];\n  const indexOfDoubleParanStart = dynamicString.indexOf(\"{{\");\n\n  if (indexOfDoubleParanStart === -1) {\n    return [dynamicString];\n  }\n\n  //{{}}{{}}}\n  const firstString = dynamicString.substring(0, indexOfDoubleParanStart);\n\n  firstString && stringSegments.push(firstString);\n  let rest = dynamicString.substring(\n    indexOfDoubleParanStart,\n    dynamicString.length,\n  );\n  //{{}}{{}}}\n  let sum = 0;\n\n  for (let i = 0; i <= rest.length - 1; i++) {\n    const char = rest[i];\n    const prevChar = rest[i - 1];\n\n    if (char === \"{\") {\n      sum++;\n    } else if (char === \"}\") {\n      sum--;\n\n      if (prevChar === \"}\" && sum === 0) {\n        stringSegments.push(rest.substring(0, i + 1));\n        rest = rest.substring(i + 1, rest.length);\n\n        if (rest) {\n          stringSegments = stringSegments.concat(\n            getDynamicStringSegments(rest),\n          );\n          break;\n        }\n      }\n    }\n  }\n\n  if (sum !== 0 && dynamicString !== \"\") {\n    return [dynamicString];\n  }\n\n  return stringSegments;\n}\n\n//{{}}{{}}}\nexport const getDynamicBindings = (\n  dynamicString: string,\n  entity?: DataTreeEntity,\n): { stringSegments: string[]; jsSnippets: string[] } => {\n  // Protect against bad string parse\n  if (!isString(dynamicString)) {\n    return { stringSegments: [], jsSnippets: [] };\n  }\n\n  const sanitisedString = dynamicString.trim();\n\n  if (entity && isJSAction(entity)) {\n    return { stringSegments: [sanitisedString], jsSnippets: [sanitisedString] };\n  }\n\n  // Get the {{binding}} bound values\n  const stringSegments = getDynamicStringSegments(sanitisedString);\n  // Get the \"binding\" path values\n  const jsSnippets = stringSegments.map((segment) => {\n    const length = segment.length;\n    const matches = isDynamicValue(segment);\n\n    if (matches) {\n      return segment.substring(2, length - 2);\n    }\n\n    return \"\";\n  });\n\n  return { stringSegments, jsSnippets };\n};\n\nexport const combineDynamicBindings = (\n  jsSnippets: string[],\n  stringSegments: string[],\n) => {\n  return stringSegments\n    .map((segment, index) => {\n      if (jsSnippets[index] && jsSnippets[index].length > 0) {\n        return addOperatorPrecedenceIfNeeded(jsSnippets[index]);\n      } else {\n        return JSON.stringify(segment);\n      }\n    })\n    .join(\" + \");\n};\n\n/**\n * Operator precedence example: JSCode =  Color is  {{ currentItem.color || \"Blue\"}}  PS: currentItem.color is undefined\n *  Previously this code would be transformed to  (() =>  \"Color is\" + currentItem.color || \"Blue\")() which evaluates to \"Color is undefined\" rather than \"Color is Blue\"\n * with precedence we'd have (() =>  \"Color is\" + (currentItem.color || \"Blue\"))() which evaluates to Color is Blue,  because the parentheses change the order of evaluation, giving  higher precedence in this case to (currentItem.color || \"Blue\").\n */\nfunction addOperatorPrecedenceIfNeeded(stringifiedJS: string) {\n  /**\n   *  parenthesis doesn't work with ; i.e Color is  {{ currentItem.color || \"Blue\" ;}} cant be (() =>  \"Color is\" + (currentItem.color || \"Blue\";))()\n   */\n  if (!hasNonStringSemicolons(stringifiedJS)) {\n    return `(${stringifiedJS})`;\n  }\n\n  return stringifiedJS;\n}\n\nexport enum EvalErrorTypes {\n  CYCLICAL_DEPENDENCY_ERROR = \"CYCLICAL_DEPENDENCY_ERROR\",\n  EVAL_PROPERTY_ERROR = \"EVAL_PROPERTY_ERROR\",\n  EVAL_TREE_ERROR = \"EVAL_TREE_ERROR\",\n  UNKNOWN_ERROR = \"UNKNOWN_ERROR\",\n  BAD_UNEVAL_TREE_ERROR = \"BAD_UNEVAL_TREE_ERROR\",\n  PARSE_JS_ERROR = \"PARSE_JS_ERROR\",\n  EXTRACT_DEPENDENCY_ERROR = \"EXTRACT_DEPENDENCY_ERROR\",\n  CLONE_ERROR = \"CLONE_ERROR\",\n  SERIALIZATION_ERROR = \"SERIALIZATION_ERROR\",\n}\n\nexport interface EvalError {\n  type: EvalErrorTypes;\n  message: string;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  context?: Record<string, any>;\n}\n\nexport interface DynamicPath {\n  key: string;\n  value?: string;\n}\n\nexport interface WidgetDynamicPathListProps {\n  dynamicBindingPathList?: DynamicPath[];\n  dynamicTriggerPathList?: DynamicPath[];\n  dynamicPropertyPathList?: DynamicPath[];\n}\n\nexport interface EntityWithBindings {\n  dynamicBindingPathList?: DynamicPath[];\n}\n\nexport const getEntityDynamicBindingPathList = (\n  entity: EntityWithBindings,\n): DynamicPath[] => {\n  if (\n    entity &&\n    entity.dynamicBindingPathList &&\n    Array.isArray(entity.dynamicBindingPathList)\n  ) {\n    return [...entity.dynamicBindingPathList];\n  }\n\n  return [];\n};\n\nexport const isPathADynamicBinding = (\n  entity: EntityWithBindings,\n  path: string,\n): boolean => {\n  if (\n    entity &&\n    entity.dynamicBindingPathList &&\n    Array.isArray(entity.dynamicBindingPathList)\n  ) {\n    return _.find(entity.dynamicBindingPathList, { key: path }) !== undefined;\n  }\n\n  return false;\n};\n/**\n * Get property path from full property path\n * Input: \"Table1.meta.searchText\" => Output: \"meta.searchText\"\n * @param {string} fullPropertyPath\n * @return {*}\n */\nexport const getPropertyPath = (fullPropertyPath: string) => {\n  return fullPropertyPath.substring(fullPropertyPath.indexOf(\".\") + 1);\n};\n\nexport const getWidgetDynamicTriggerPathList = (\n  widget: WidgetProps,\n): DynamicPath[] => {\n  if (\n    widget &&\n    widget.dynamicTriggerPathList &&\n    Array.isArray(widget.dynamicTriggerPathList)\n  ) {\n    return [...widget.dynamicTriggerPathList];\n  }\n\n  return [];\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const isPathDynamicTrigger = (widget: any, path: string): boolean => {\n  if (\n    widget &&\n    widget.dynamicTriggerPathList &&\n    Array.isArray(widget.dynamicTriggerPathList)\n  ) {\n    return _.find(widget.dynamicTriggerPathList, { key: path }) !== undefined;\n  }\n\n  return false;\n};\n\nexport const getWidgetDynamicPropertyPathList = (\n  widget: WidgetProps,\n): DynamicPath[] => {\n  if (\n    widget &&\n    widget.dynamicPropertyPathList &&\n    Array.isArray(widget.dynamicPropertyPathList)\n  ) {\n    return [...widget.dynamicPropertyPathList];\n  }\n\n  return [];\n};\n\nexport const isPathDynamicProperty = (\n  widget: WidgetProps,\n  path: string,\n): boolean => {\n  if (\n    widget &&\n    widget.dynamicPropertyPathList &&\n    Array.isArray(widget.dynamicPropertyPathList)\n  ) {\n    return _.find(widget.dynamicPropertyPathList, { key: path }) !== undefined;\n  }\n\n  return false;\n};\n\nexport const THEME_BINDING_REGEX = /{{.*appsmith\\.theme\\..*}}/;\n\nexport const isThemeBoundProperty = (\n  widget: WidgetProps,\n  path: string,\n): boolean => {\n  return widget && widget[path] && THEME_BINDING_REGEX.test(widget[path]);\n};\n\nexport const unsafeFunctionForEval = [\n  \"XMLHttpRequest\",\n  \"setImmediate\",\n  \"Navigator\",\n];\n\nexport const isChildPropertyPath = (\n  parentPropertyPath: string,\n  childPropertyPath: string,\n  // In non-strict mode, an exact match is treated as a child path\n  // Eg. \"Api1\" is a child property path of \"Api1\"\n  strict = false,\n): boolean => {\n  return (\n    (!strict && parentPropertyPath === childPropertyPath) ||\n    childPropertyPath.startsWith(`${parentPropertyPath}.`) ||\n    childPropertyPath.startsWith(`${parentPropertyPath}[`)\n  );\n};\n\n/**\n * Paths set via evaluator on entities\n * During evaluation, the evaluator will set various data points\n * on the entity objects to describe their state while evaluating.\n * This information can be found on the following paths\n * These paths are meant to be objects with\n * information about the properties in\n * a single place\n *\n * Stored in a flattened object like\n * widget.__evaluation__.errors.primaryColumns.customColumn.computedValue = [...]\n **/\nexport const EVALUATION_PATH = \"__evaluation__\";\nexport const EVAL_ERROR_PATH = `${EVALUATION_PATH}.errors`;\nexport const EVAL_VALUE_PATH = `${EVALUATION_PATH}.evaluatedValues`;\n\n/**\n * non-populated object\n {\n   __evaluation__:{\n     evaluatedValues:{\n       primaryColumns: [...],\n       primaryColumns.status: {...},\n       primaryColumns.action: {...}\n     }\n   }\n }\n\n * Populated Object\n {\n   __evaluation__:{\n     evaluatedValues:{\n       primaryColumns: {\n         status: [...],\n         action:[...]\n        }\n     }\n   }\n }\n\n */\nconst getNestedEvalPath = (\n  fullPropertyPath: string,\n  pathType: string,\n  fullPath = true,\n  isPopulated = false,\n) => {\n  const { entityName, propertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const nestedPath = isPopulated\n    ? `${pathType}.${propertyPath}`\n    : `${pathType}.['${propertyPath}']`;\n\n  if (fullPath) {\n    return `${entityName}.${nestedPath}`;\n  }\n\n  return nestedPath;\n};\n\nexport const getEvalErrorPath = (\n  fullPropertyPath: string,\n  options = {\n    fullPath: true,\n    isPopulated: false,\n  },\n) => {\n  return getNestedEvalPath(\n    fullPropertyPath,\n    EVAL_ERROR_PATH,\n    options.fullPath,\n    options.isPopulated,\n  );\n};\n\nexport const getEvalValuePath = (\n  fullPropertyPath: string,\n  options = {\n    fullPath: true,\n    isPopulated: false,\n  },\n) => {\n  return getNestedEvalPath(\n    fullPropertyPath,\n    EVAL_VALUE_PATH,\n    options.fullPath,\n    options.isPopulated,\n  );\n};\n\nexport enum PropertyEvaluationErrorType {\n  VALIDATION = \"VALIDATION\",\n  PARSE = \"PARSE\",\n  LINT = \"LINT\",\n}\n\nexport enum PropertyEvaluationErrorCategory {\n  ACTION_INVOCATION_IN_DATA_FIELD = \"ACTION_INVOCATION_IN_DATA_FIELD\",\n}\nexport interface PropertyEvaluationErrorKind {\n  category: PropertyEvaluationErrorCategory;\n  rootcause: string;\n}\n\nexport interface DataTreeError {\n  raw: string;\n  errorMessage: Error;\n  severity: Severity.WARNING | Severity.ERROR;\n}\n\nexport interface EvaluationError extends DataTreeError {\n  errorType:\n    | PropertyEvaluationErrorType.PARSE\n    | PropertyEvaluationErrorType.VALIDATION;\n  originalBinding?: string;\n  kind?: Partial<PropertyEvaluationErrorKind>;\n}\n\nexport interface LintError extends DataTreeError {\n  errorType: PropertyEvaluationErrorType.LINT;\n  errorSegment: string;\n  originalBinding: string;\n  variables: (string | undefined | null)[];\n  code: string;\n  line: number;\n  ch: number;\n  originalPath?: string;\n  lintLength?: number;\n}\n\nexport interface DataTreeEvaluationProps {\n  __evaluation__?: {\n    errors: Record<string, EvaluationError[]>;\n    evaluatedValues?: Record<string, unknown>;\n  };\n}\n\nexport const PropertyEvalErrorTypeDebugMessage: Record<\n  PropertyEvaluationErrorType,\n  (propertyPath: string) => string\n> = {\n  [PropertyEvaluationErrorType.VALIDATION]: (propertyPath: string) =>\n    `The value at ${propertyPath} is invalid`,\n  [PropertyEvaluationErrorType.PARSE]: () => `Could not parse the binding`,\n  [PropertyEvaluationErrorType.LINT]: () => `Errors found while evaluating`,\n};\n\n// this variable temporarily holds dynamic paths generated by the recursive function (getDynamicValuePaths - Line 468).\nlet temporaryDynamicPathStore: DynamicPath[] = [];\n\n// recursive function to get full key path of any object that has dynamic bindings.\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst getDynamicValuePaths = (val: any, parentPath: string) => {\n  if (isString(val) && isDynamicValue(val)) {\n    return temporaryDynamicPathStore.push({ key: `${parentPath}` });\n  }\n\n  if (Array.isArray(val)) {\n    val.forEach((obj, index) => {\n      return getDynamicValuePaths(obj, `${parentPath}[${index}]`);\n    });\n  }\n\n  if (isTrueObject(val)) {\n    Object.entries(val).forEach(([key, value]) => {\n      getDynamicValuePaths(value, `${parentPath}.${key}`);\n    });\n  }\n};\n\nexport function getDynamicBindingsChangesSaga(\n  action: Action,\n  value: unknown,\n  field: string,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  formData?: any,\n) {\n  const bindingField = field.replace(\"actionConfiguration.\", \"\");\n  // we listen to any viewType changes.\n  const viewType = field.endsWith(\".viewType\");\n  let dynamicBindings: DynamicPath[] = action.dynamicBindingPathList\n    ? [...action.dynamicBindingPathList]\n    : [];\n\n  if (field.endsWith(\".jsonData\") || field.endsWith(\".componentData\")) {\n    return dynamicBindings;\n  }\n\n  if (\n    action.datasource &&\n    (\"datasourceConfiguration\" in action.datasource ||\n      \"datasourceConfiguration\" in (formData?.datasource || {})) &&\n    field === \"datasource\"\n  ) {\n    // only the datasource.datasourceConfiguration.url can be a dynamic field\n    dynamicBindings = dynamicBindings.filter(\n      (binding) => binding.key !== \"datasourceUrl\" && binding.key !== \"path\",\n    );\n    // ideally as we check for the datasource url, we should check for the path field as well.\n    const datasourceUrl = action.datasource?.datasourceConfiguration?.url || \"\";\n    const datasourcePathField = action.actionConfiguration?.path;\n    const datasourceFormPathField = formData?.actionConfiguration?.path;\n\n    isDynamicValue(datasourceUrl) &&\n      dynamicBindings.push({ key: \"datasourceUrl\" });\n\n    // as we check the datasource url for bindings, check the path too.\n    isDynamicValue(datasourcePathField || datasourceFormPathField) &&\n      dynamicBindings.push({ key: \"path\" });\n\n    return dynamicBindings;\n  }\n\n  // When a key-value pair is added or deleted from a fieldArray\n  // Value is an Array representing the new fieldArray.\n\n  if (Array.isArray(value)) {\n    // first we clear the dynamic bindings of any paths that is a child of the current path.\n    dynamicBindings = dynamicBindings.filter(\n      (binding) => !isChildPropertyPath(bindingField, binding.key),\n    );\n\n    // then we recursively go through the value and find paths with dynamic bindings\n    temporaryDynamicPathStore = [];\n\n    if (!!value) {\n      getDynamicValuePaths(value, bindingField);\n    }\n\n    if (!!temporaryDynamicPathStore && temporaryDynamicPathStore.length > 0) {\n      dynamicBindings = [...dynamicBindings, ...temporaryDynamicPathStore];\n    }\n  } else if (getType(value) === Types.OBJECT) {\n    dynamicBindings = dynamicBindings.filter((dynamicPath) => {\n      if (isChildPropertyPath(bindingField, dynamicPath.key)) {\n        const childPropertyValue = _.get(value, dynamicPath.key);\n\n        return isDynamicValue(childPropertyValue);\n      }\n\n      return !!dynamicPath;\n    });\n  } else if (typeof value === \"string\") {\n    const fieldExists = _.some(dynamicBindings, { key: bindingField });\n\n    const isDynamic = isDynamicValue(value);\n\n    if (!isDynamic && fieldExists) {\n      dynamicBindings = dynamicBindings.filter((d) => d.key !== bindingField);\n    }\n\n    if (isDynamic && !fieldExists) {\n      dynamicBindings = [...dynamicBindings, { key: bindingField }];\n    }\n  }\n\n  // the reason this is done is to change the dynamicBindingsPathlist of a component when a user toggles the form control\n  // from component mode to json mode and vice versa.\n\n  // when in json mode, we want to get rid of all the existing componentData paths and replace it with a single path for the json mode\n  // for example: [{key: 'formData.sortBy.data[0].column'}, {key: 'formData.sortBy.data[1].column'}] will be replaced with just this [{key: 'formData.sortBy.data'}]\n\n  // when in component mode, we want to first remove all the paths for json mode and\n  //  get back all the paths in the componentData that have dynamic bindings and add them to the the dynamic bindings pathlist.\n  // for example: [{key: 'formData.sortBy.data'}] will be replaced with this [{key: 'formData.sortBy.data[0].column'}, {key: 'formData.sortBy.data[1].column'}]\n\n  // if the currently changing field is a component's view type\n  if (!!viewType) {\n    const dataBindingField = bindingField.replace(\".viewType\", \".data\");\n\n    // then we filter the field of any paths that includes the binding fields\n    dynamicBindings = dynamicBindings.filter(\n      (dynamicPath) => !dynamicPath?.key?.includes(dataBindingField),\n    );\n\n    // if the value of the viewType is of json and, we push in the field\n    if (value === ViewTypes.JSON) {\n      const jsonFieldPath = field.replace(\".viewType\", \".jsonData\");\n      const jsonFieldValue = get(action, jsonFieldPath);\n\n      if (isDynamicValue(jsonFieldValue)) {\n        dynamicBindings.push({ key: dataBindingField });\n      }\n    } else if (value === ViewTypes.COMPONENT) {\n      const componentFieldPath = field.replace(\".viewType\", \".componentData\");\n      const componentFieldValue = get(action, componentFieldPath);\n\n      temporaryDynamicPathStore = [];\n\n      if (!!componentFieldValue) {\n        getDynamicValuePaths(componentFieldValue, dataBindingField);\n      }\n\n      if (!!temporaryDynamicPathStore && temporaryDynamicPathStore.length > 0) {\n        dynamicBindings = [...dynamicBindings, ...temporaryDynamicPathStore];\n      }\n    }\n  }\n\n  return dynamicBindings;\n}\n\nexport function getEntityType(entity: DataTreeEntity) {\n  return \"ENTITY_TYPE\" in entity && entity.ENTITY_TYPE;\n}\n\nexport function getEntityId(entity: DataTreeEntity) {\n  if (isAction(entity)) return entity.actionId;\n\n  if (isWidget(entity)) return entity.widgetId;\n\n  if (isJSAction(entity)) return entity.actionId;\n}\n\nexport function getEntityName(\n  entity: DataTreeEntity,\n  entityConfig: DataTreeEntityConfig,\n) {\n  if (isAction(entity)) return entityConfig.name;\n\n  if (isWidget(entity)) return entity.widgetName;\n\n  if (isJSAction(entity)) return entityConfig.name;\n}\n","import type { FeatureFlags } from \"ee/entities/FeatureFlag\";\n\nexport class WorkerEnv {\n  static flags: FeatureFlags = {} as FeatureFlags;\n  static cloudHosting: boolean;\n\n  static setFeatureFlags(featureFlags: FeatureFlags) {\n    WorkerEnv.flags = featureFlags;\n  }\n\n  static setCloudHosting(cloudHosting: boolean) {\n    WorkerEnv.cloudHosting = cloudHosting;\n  }\n\n  static getFeatureFlags() {\n    return WorkerEnv.flags;\n  }\n\n  static getCloudHosting() {\n    return WorkerEnv.cloudHosting;\n  }\n}\n","import { ActionCalledInSyncFieldError } from \"workers/Evaluation/errorModifier\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype FnGuard = (fn: (...args: any[]) => unknown, fnName: string) => unknown;\n\nexport function addFn(\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ctx: any,\n  fnName: string,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  fn: (...args: any[]) => any,\n  fnGuards = [isAsyncGuard],\n) {\n  Object.defineProperty(ctx, fnName, {\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    value: function (...args: any[]) {\n      const fnWithGuards = getFnWithGuards(fn, fnName, fnGuards);\n\n      return fnWithGuards(...args);\n    },\n    enumerable: false,\n    writable: true,\n    configurable: true,\n  });\n}\n\nexport function isAsyncGuard<P extends ReadonlyArray<unknown>>(\n  fn: (...args: P) => unknown,\n  fnName: string,\n) {\n  if (self.$isDataField) {\n    self[\"$isAsync\"] = true;\n    throw new ActionCalledInSyncFieldError(fnName);\n  }\n}\n\nexport function getFnWithGuards(\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  fn: (...args: any[]) => unknown,\n  fnName: string,\n  fnGuards: FnGuard[],\n) {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (...args: any[]) => {\n    for (const guard of fnGuards) {\n      guard(fn, fnName);\n    }\n\n    return fn(...args);\n  };\n}\n","import type {\n  JSActionEntityConfig,\n  JSActionEntity,\n} from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport { EvaluationSubstitutionType } from \"ee/entities/DataTree/types\";\nimport type { ParsedBody, ParsedJSSubAction } from \"utils/JSPaneUtils\";\nimport { unset, set, get, find } from \"lodash\";\nimport type {\n  BatchedJSExecutionData,\n  BatchedJSExecutionErrors,\n  JSCollectionData,\n  JSExecutionData,\n  JSExecutionError,\n} from \"ee/reducers/entityReducers/jsActionsReducer\";\nimport { select } from \"redux-saga/effects\";\nimport type { JSAction } from \"entities/JSCollection\";\nimport { getAllJSCollections } from \"ee/selectors/entitiesSelector\";\nimport {\n  getEntityNameAndPropertyPath,\n  isJSAction,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport JSObjectCollection from \"./Collection\";\n\n/**\n * here we add/remove the properties (variables and actions) which got added/removed from the JSObject parsedBody.\n  NOTE: For other entity below logic is maintained in DataTreeFactory, for JSObject we handle it inside evaluations\n *\n * @param parsedBody\n * @param jsCollection\n * @param unEvalTree\n * @returns\n */\nexport const updateJSCollectionInUnEvalTree = (\n  parsedBody: ParsedBody,\n  jsCollection: JSActionEntity,\n  unEvalTree: DataTree,\n  configTree: ConfigTree,\n  entityName: string,\n) => {\n  // jsCollection here means unEvalTree JSObject\n  const modifiedUnEvalTree = unEvalTree;\n  const functionsList: Array<string> = [];\n  const jsEntityConfig = configTree[entityName] as JSActionEntityConfig;\n  const varList: Array<string> | undefined = jsEntityConfig?.variables;\n\n  Object.keys(jsEntityConfig?.meta).forEach((action) => {\n    functionsList.push(action);\n  });\n  const oldConfig = jsEntityConfig;\n\n  if (parsedBody.actions && parsedBody.actions.length > 0) {\n    for (let i = 0; i < parsedBody.actions.length; i++) {\n      const action = parsedBody.actions[i];\n\n      if (jsCollection.hasOwnProperty(action.name)) {\n        if (jsCollection[action.name] !== action.body) {\n          const data = get(\n            modifiedUnEvalTree,\n            `${entityName}.${action.name}.data`,\n            {},\n          );\n\n          set(\n            modifiedUnEvalTree,\n            `${entityName}.${action.name}`,\n            new String(action.body),\n          );\n\n          set(modifiedUnEvalTree, `${entityName}.${action.name}.data`, data);\n        }\n      } else {\n        const reactivePaths = oldConfig.reactivePaths;\n\n        reactivePaths[action.name] =\n          EvaluationSubstitutionType.SMART_SUBSTITUTE;\n        reactivePaths[`${action.name}.data`] =\n          EvaluationSubstitutionType.TEMPLATE;\n\n        const dynamicBindingPathList = oldConfig.dynamicBindingPathList;\n\n        dynamicBindingPathList.push({ key: action.name });\n\n        const dependencyMap = oldConfig.dependencyMap;\n\n        dependencyMap[\"body\"].push(action.name);\n\n        const meta = oldConfig.meta;\n\n        meta[action.name] = {\n          arguments: action.arguments,\n          confirmBeforeExecute: false,\n        };\n\n        const data = get(\n          modifiedUnEvalTree,\n          `${entityName}.${action.name}.data`,\n          {},\n        );\n\n        set(\n          modifiedUnEvalTree,\n          `${entityName}.${action.name}`,\n          new String(action.body.toString()),\n        );\n        set(modifiedUnEvalTree, `${entityName}.${action.name}.data`, data);\n      }\n    }\n  }\n\n  if (functionsList && functionsList.length > 0) {\n    for (let i = 0; i < functionsList.length; i++) {\n      const oldActionName = functionsList[i];\n      const existed = parsedBody.actions.find(\n        (js: ParsedJSSubAction) => js.name === oldActionName,\n      );\n\n      if (!existed) {\n        const reactivePaths = oldConfig.reactivePaths;\n\n        delete reactivePaths[oldActionName];\n\n        oldConfig.dynamicBindingPathList =\n          oldConfig.dynamicBindingPathList.filter(\n            // TODO: Fix this the next time the file is edited\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (path: any) => path[\"key\"] !== oldActionName,\n          );\n\n        const dependencyMap = oldConfig.dependencyMap[\"body\"];\n        const removeIndex = dependencyMap.indexOf(oldActionName);\n\n        if (removeIndex > -1) {\n          oldConfig.dependencyMap[\"body\"] = dependencyMap.filter(\n            // TODO: Fix this the next time the file is edited\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (item: any) => item !== oldActionName,\n          );\n        }\n\n        const meta = oldConfig.meta;\n\n        delete meta[oldActionName];\n\n        unset(modifiedUnEvalTree[entityName], oldActionName);\n        unset(modifiedUnEvalTree[entityName], `${oldActionName}.data`);\n      }\n    }\n  }\n\n  if (parsedBody.variables.length && varList) {\n    for (let i = 0; i < parsedBody.variables.length; i++) {\n      const newVar = parsedBody.variables[i];\n      const existedVar = varList.indexOf(newVar.name);\n\n      if (existedVar > -1) {\n        const existedVarVal = jsCollection[newVar.name];\n\n        if (\n          (!!existedVarVal && existedVarVal.toString()) !==\n            (newVar.value && newVar.value.toString()) ||\n          (!existedVarVal && !!newVar)\n        ) {\n          set(modifiedUnEvalTree, `${entityName}.${newVar.name}`, newVar.value);\n          // When user updates the JSObject all the variable's reset's to initial value\n          JSObjectCollection.removeVariable(`${entityName}.${newVar.name}`);\n        }\n      } else {\n        varList.push(newVar.name);\n        const reactivePaths = oldConfig.reactivePaths;\n\n        reactivePaths[newVar.name] =\n          EvaluationSubstitutionType.SMART_SUBSTITUTE;\n\n        const dynamicBindingPathList = oldConfig.dynamicBindingPathList;\n\n        dynamicBindingPathList.push({ key: newVar.name });\n\n        set(configTree, `${entityName}.variables`, varList);\n        set(modifiedUnEvalTree, `${entityName}.${newVar.name}`, newVar.value);\n        // When user updates the JSObject all the variable's reset's to initial value\n        JSObjectCollection.removeVariable(`${entityName}.${newVar.name}`);\n      }\n    }\n\n    let newVarList: Array<string> = varList;\n\n    for (let i = 0; i < varList.length; i++) {\n      const varListItem = varList[i];\n      const existsInParsed = parsedBody.variables.find(\n        (item) => item.name === varListItem,\n      );\n\n      if (!existsInParsed) {\n        const reactivePaths = oldConfig.reactivePaths;\n\n        delete reactivePaths[varListItem];\n\n        oldConfig.dynamicBindingPathList =\n          oldConfig.dynamicBindingPathList.filter(\n            // TODO: Fix this the next time the file is edited\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (path: any) => path[\"key\"] !== varListItem,\n          );\n\n        newVarList = newVarList.filter((item) => item !== varListItem);\n        unset(modifiedUnEvalTree[entityName], varListItem);\n      }\n    }\n\n    if (newVarList.length) {\n      set(configTree, `${entityName}.variables`, newVarList);\n    }\n  }\n\n  return modifiedUnEvalTree;\n};\n\n/**\n * When JSObject parseBody is empty we remove all variables and actions from unEvalTree\n * this will lead to removal of properties from the dataTree\n * @param unEvalTree\n * @param entity\n * @returns\n */\nexport const removeFunctionsAndVariableJSCollection = (\n  unEvalTree: DataTree,\n  entity: JSActionEntity,\n  entityName: string,\n  configTree: ConfigTree,\n) => {\n  const oldConfig = configTree[entityName] as JSActionEntityConfig;\n  const modifiedDataTree: DataTree = unEvalTree;\n  const functionsList: Array<string> = [];\n\n  Object.keys(oldConfig.meta).forEach((action) => {\n    functionsList.push(action);\n  });\n  //removed variables\n  const varList: Array<string> | undefined = oldConfig.variables;\n\n  set(oldConfig, `${entityName}.variables`, []);\n\n  if (varList) {\n    for (let i = 0; i < varList.length; i++) {\n      const varName = varList[i];\n\n      unset(modifiedDataTree[entityName], varName);\n      // When user updates the JSObject all the variable's reset's to initial value\n      JSObjectCollection.removeVariable(`${entityName}.${varName}`);\n    }\n  }\n\n  //remove functions\n  const reactivePaths = entity.reactivePaths;\n  const meta = entity.meta;\n\n  for (let i = 0; i < functionsList.length; i++) {\n    const actionName = functionsList[i];\n\n    delete reactivePaths[actionName];\n    delete meta[actionName];\n    unset(modifiedDataTree[entityName], actionName);\n\n    oldConfig.dynamicBindingPathList = oldConfig.dynamicBindingPathList.filter(\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (path: any) => path[\"key\"] !== actionName,\n    );\n\n    oldConfig.dependencyMap[\"body\"] = entity.dependencyMap[\"body\"].filter(\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (item: any) => item !== actionName,\n    );\n  }\n\n  return modifiedDataTree;\n};\n\nexport function isJSObjectFunction(\n  dataTree: DataTree,\n  jsObjectName: string,\n  key: string,\n  configTree: ConfigTree,\n) {\n  const entityConfig = configTree[jsObjectName] as JSActionEntityConfig;\n  const entity = dataTree[jsObjectName];\n\n  if (isJSAction(entity)) {\n    return entityConfig.meta.hasOwnProperty(key);\n  }\n\n  return false;\n}\n\nexport function isJSObjectVariable(\n  jsObjectName: string,\n  key: string,\n  configTree: ConfigTree,\n) {\n  const entityConfig = configTree[jsObjectName] as JSActionEntityConfig;\n\n  if (!entityConfig) return false;\n\n  const entity = configTree[jsObjectName];\n  const variables = entityConfig.variables;\n\n  return (\n    isJSAction(entity as unknown as DataTreeEntity) && variables?.includes(key)\n  );\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isPromise(value: any): value is Promise<unknown> {\n  return Boolean(value && typeof value.then === \"function\");\n}\n\nfunction updateJSExecutionError(\n  errors: BatchedJSExecutionErrors,\n  executionError: JSExecutionError,\n) {\n  const { collectionId } = executionError;\n\n  if (errors[collectionId]) {\n    errors[collectionId].push(executionError);\n  } else {\n    errors[collectionId] = [executionError];\n  }\n}\n\nfunction updateJSExecutionData(\n  sortedData: BatchedJSExecutionData,\n  executionData: JSExecutionData,\n) {\n  const { collectionId } = executionData;\n\n  if (sortedData[collectionId]) {\n    sortedData[collectionId].push(executionData);\n  } else {\n    sortedData[collectionId] = [executionData];\n  }\n}\n\nfunction getJSActionFromJSCollections(\n  jsCollections: JSCollectionData[],\n  jsfuncFullName: string,\n) {\n  const { entityName: collectionName, propertyPath: functionName } =\n    getEntityNameAndPropertyPath(jsfuncFullName);\n\n  const jsCollection = find(\n    jsCollections,\n    (collection) => collection.config.name === collectionName,\n  );\n\n  if (!jsCollection) return;\n\n  const jsAction: JSAction | undefined = find(\n    jsCollection.config.actions,\n    (action) => action.name === functionName,\n  );\n\n  return jsAction;\n}\n\nexport function* sortJSExecutionDataByCollectionId(\n  data: Record<string, unknown>,\n  errors: Record<string, unknown>,\n) {\n  // Sorted data by collectionId\n  const sortedData: BatchedJSExecutionData = {};\n  // Sorted errors by collectionId\n  const sortedErrors: BatchedJSExecutionErrors = {};\n\n  const JSCollectionsForCurrentPage: JSCollectionData[] =\n    yield select(getAllJSCollections);\n\n  for (const jsfuncFullName of Object.keys(data)) {\n    const jsAction = getJSActionFromJSCollections(\n      JSCollectionsForCurrentPage,\n      jsfuncFullName,\n    );\n\n    if (!(jsAction && jsAction.collectionId)) continue;\n\n    const { collectionId, id: actionId } = jsAction;\n\n    if (errors[jsfuncFullName]) {\n      updateJSExecutionError(sortedErrors, {\n        collectionId,\n        isDirty: true,\n        actionId,\n      });\n    }\n\n    updateJSExecutionData(sortedData, {\n      collectionId,\n      actionId,\n      data: get(data, jsfuncFullName),\n    });\n  }\n\n  return { sortedData, sortedErrors };\n}\n","import { find, toPath, union } from \"lodash\";\nimport type { EvalError } from \"utils/DynamicBindingUtils\";\nimport { EvalErrorTypes } from \"utils/DynamicBindingUtils\";\nimport { extractIdentifierInfoFromCode } from \"@shared/ast\";\nimport {\n  convertPathToString,\n  getEntityNameAndPropertyPath,\n  isJSActionConfig,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\n\nimport type { WidgetEntityConfig } from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport {\n  DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS,\n  JAVASCRIPT_KEYWORDS,\n} from \"constants/WidgetValidation\";\nimport { libraryReservedIdentifiers } from \"workers/common/JSLibrary\";\n\n/** This function extracts validReferences and invalidReferences from a binding {{}}\n * @param script\n * @param allPaths\n * @returns validReferences - Valid references from bindings\n * invalidReferences- References which are currently invalid\n * @example - For binding {{unknownEntity.name + Api1.name}}, it returns\n * {\n * validReferences:[Api1.name],\n * invalidReferences: [unknownEntity.name]\n * }\n */\nexport const extractInfoFromBinding = (\n  script: string,\n  allKeys: Record<string, true>,\n) => {\n  const { references } = extractIdentifierInfoFromCode(\n    script,\n    self.evaluationVersion,\n    invalidEntityIdentifiers,\n  );\n\n  return getPrunedReferences(references, allKeys);\n};\n\nexport const getPrunedReferences = (\n  references: string[],\n  allKeys: Record<string, true>,\n) => {\n  const prunedReferences: Set<string> = new Set<string>();\n\n  references.forEach((reference: string) => {\n    // If the identifier exists directly, add it and return\n    if (allKeys.hasOwnProperty(reference)) {\n      prunedReferences.add(reference);\n\n      return;\n    }\n\n    const subpaths = toPath(reference);\n    let current = \"\";\n\n    // We want to keep going till we reach top level, but not add top level\n    // Eg: Input1.text should not depend on entire Table1 unless it explicitly asked for that.\n    // This is mainly to avoid a lot of unnecessary evals, if we feel this is wrong\n    // we can remove the length requirement, and it will still work\n    while (subpaths.length > 1) {\n      current = convertPathToString(subpaths);\n\n      // We've found the dep, add it and return\n      if (allKeys.hasOwnProperty(current)) {\n        prunedReferences.add(current);\n\n        return;\n      }\n\n      subpaths.pop();\n    }\n\n    // If no valid reference is derived, add reference as is\n    prunedReferences.add(reference);\n  });\n\n  return Array.from(prunedReferences);\n};\n\ninterface BindingsInfo {\n  references: string[];\n  errors: EvalError[];\n}\nexport const extractInfoFromBindings = (\n  bindings: string[],\n  allKeys: Record<string, true>,\n) => {\n  return bindings.reduce(\n    (bindingsInfo: BindingsInfo, binding) => {\n      try {\n        const references = extractInfoFromBinding(binding, allKeys);\n\n        return {\n          ...bindingsInfo,\n          references: union(bindingsInfo.references, references),\n        };\n      } catch (error) {\n        const newEvalError: EvalError = {\n          type: EvalErrorTypes.EXTRACT_DEPENDENCY_ERROR,\n          message: (error as Error).message,\n          context: {\n            script: binding,\n          },\n        };\n\n        return {\n          ...bindingsInfo,\n          errors: union(bindingsInfo.errors, [newEvalError]),\n        };\n      }\n    },\n    { references: [], errors: [] },\n  );\n};\n\n/**This function returns a unique array containing a merge of both arrays\n * @param currentArr\n * @param updateArr\n * @returns A unique array containing a merge of both arrays\n */\nexport const mergeArrays = <T>(currentArr: T[], updateArr: T[]): T[] => {\n  if (!currentArr) return updateArr;\n\n  return union(currentArr, updateArr);\n};\n\n/**\n * Identifiers which can not be valid names of entities and are not dynamic in nature.\n * therefore should be removed from the list of references extracted from code.\n * NB: DATA_TREE_KEYWORDS in app/client/src/constants/WidgetValidation.ts isn't included, although they are not valid entity names,\n * they can refer to potentially dynamic entities.\n * Eg. \"appsmith\"\n */\nexport const invalidEntityIdentifiers: Record<string, unknown> = {\n  ...JAVASCRIPT_KEYWORDS,\n  ...DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS,\n  ...libraryReservedIdentifiers,\n};\n\nexport function isADynamicTriggerPath(\n  entity: DataTreeEntity,\n  propertyPath: string,\n  entityConfig: WidgetEntityConfig,\n) {\n  if (isWidget(entity)) {\n    const dynamicTriggerPathlist = entityConfig?.dynamicTriggerPathList;\n    const isTriggerPath = find(dynamicTriggerPathlist, { key: propertyPath });\n\n    if (isTriggerPath) {\n      return true;\n    }\n\n    return false;\n  }\n}\n\nexport function isJSFunction(configTree: ConfigTree, fullPath: string) {\n  const { entityName, propertyPath } = getEntityNameAndPropertyPath(fullPath);\n  const entityConfig = configTree[entityName];\n\n  return (\n    isJSActionConfig(entityConfig) &&\n    propertyPath &&\n    propertyPath in entityConfig.meta\n  );\n}\nexport function convertArrayToObject(arr: string[]) {\n  return arr.reduce(\n    (acc, item) => {\n      return { ...acc, [item]: true } as const;\n    },\n    {} as Record<string, true>,\n  );\n}\n","/* eslint-disable no-console */\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type { EvaluationError } from \"utils/DynamicBindingUtils\";\nimport { PropertyEvaluationErrorType } from \"utils/DynamicBindingUtils\";\nimport unescapeJS from \"unescape-js\";\nimport { Severity } from \"entities/AppsmithConsole\";\nimport type { EventType } from \"constants/AppsmithActionConstants/ActionConstants\";\nimport type { TriggerMeta } from \"ee/sagas/ActionExecution/ActionExecutionSagas\";\nimport indirectEval from \"./indirectEval\";\nimport DOM_APIS from \"./domApis\";\nimport {\n  JSLibraryAccessor,\n  libraryReservedIdentifiers,\n} from \"../common/JSLibrary\";\nimport {\n  ActionInDataFieldErrorModifier,\n  errorModifier,\n  FoundPromiseInSyncEvalError,\n  PrimitiveErrorModifier,\n  TypeErrorModifier,\n} from \"./errorModifier\";\nimport { getDataTreeContext } from \"ee/workers/Evaluation/Actions\";\nimport { set } from \"lodash\";\nimport { klona } from \"klona\";\nimport { getEntityNameAndPropertyPath } from \"ee/workers/Evaluation/evaluationUtils\";\n\nexport interface EvalResult {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  result: any;\n  errors: EvaluationError[];\n}\n\nexport enum EvaluationScriptType {\n  EXPRESSION = \"EXPRESSION\",\n  ANONYMOUS_FUNCTION = \"ANONYMOUS_FUNCTION\",\n  ASYNC_ANONYMOUS_FUNCTION = \"ASYNC_ANONYMOUS_FUNCTION\",\n  TRIGGERS = \"TRIGGERS\",\n  OBJECT_PROPERTY = \"OBJECT_PROPERTY\",\n}\n\nexport const ScriptTemplate = \"<<string>>\";\n\nexport const EvaluationScripts: Record<EvaluationScriptType, string> = {\n  [EvaluationScriptType.EXPRESSION]: `\n  function $$closedFn () {\n    const $$result = ${ScriptTemplate}\n    return $$result\n  }\n  $$closedFn.call(THIS_CONTEXT)\n  `,\n  [EvaluationScriptType.ANONYMOUS_FUNCTION]: `\n  function $$closedFn (script) {\n    const $$userFunction = script;\n    const $$result = $$userFunction?.apply(THIS_CONTEXT, ARGUMENTS);\n    return $$result\n  }\n  $$closedFn(${ScriptTemplate})\n  `,\n  [EvaluationScriptType.ASYNC_ANONYMOUS_FUNCTION]: `\n  async function $$closedFn (script) {\n    const $$userFunction = script;\n    const $$result = $$userFunction?.apply(THIS_CONTEXT, ARGUMENTS);\n    return await $$result;\n  }\n  $$closedFn(${ScriptTemplate})\n  `,\n  [EvaluationScriptType.TRIGGERS]: `\n  async function $$closedFn () {\n    const $$result = ${ScriptTemplate};\n    return await $$result\n  }\n  $$closedFn.call(THIS_CONTEXT)\n  `,\n  [EvaluationScriptType.OBJECT_PROPERTY]: `\n  function $$closedFn () {\n    const $$result = {${ScriptTemplate}}\n    return $$result\n  }\n  $$closedFn.call(THIS_CONTEXT)\n  `,\n};\n\nconst topLevelWorkerAPIs = Object.keys(self).reduce(\n  (acc, key: string) => {\n    acc[key] = true;\n\n    return acc;\n  },\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  {} as any,\n);\n\nconst ignoreGlobalObjectKeys = new Set([\n  \"evaluationVersion\",\n  \"window\",\n  \"document\",\n  \"location\",\n]);\n\nexport function resetWorkerGlobalScope() {\n  const jsLibraryAccessorSet = JSLibraryAccessor.getSet();\n\n  for (const key of Object.keys(self)) {\n    if (topLevelWorkerAPIs[key] || DOM_APIS[key]) continue;\n\n    //TODO: Remove this once we have a better way to handle this\n    if (ignoreGlobalObjectKeys.has(key)) continue;\n\n    if (jsLibraryAccessorSet.has(key)) continue;\n\n    if (libraryReservedIdentifiers[key]) continue;\n\n    try {\n      // @ts-expect-error: Types are not available\n      delete self[key];\n    } catch (e) {\n      // @ts-expect-error: Types are not available\n      self[key] = undefined;\n    }\n  }\n}\n\nexport const getScriptType = (\n  evalArgumentsExist = false,\n  isTriggerBased = false,\n): EvaluationScriptType => {\n  let scriptType = EvaluationScriptType.EXPRESSION;\n\n  if (evalArgumentsExist && isTriggerBased) {\n    scriptType = EvaluationScriptType.ASYNC_ANONYMOUS_FUNCTION;\n  } else if (evalArgumentsExist && !isTriggerBased) {\n    scriptType = EvaluationScriptType.ANONYMOUS_FUNCTION;\n  } else if (isTriggerBased && !evalArgumentsExist) {\n    scriptType = EvaluationScriptType.TRIGGERS;\n  }\n\n  return scriptType;\n};\n\nexport const additionalLibrariesNames: string[] = [];\n\nexport const getScriptToEval = (\n  userScript: string,\n  type: EvaluationScriptType,\n): string => {\n  // Using replace here would break scripts with replacement patterns (ex: $&, $$)\n  const buffer = EvaluationScripts[type].split(ScriptTemplate);\n\n  return `${buffer[0]}${userScript}${buffer[1]}`;\n};\n\nconst beginsWithLineBreakRegex = /^\\s+|\\s+$/;\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type EvalContext = Record<string, any>;\n\nexport interface createEvaluationContextArgs {\n  dataTree: DataTree;\n  configTree?: ConfigTree;\n  context?: EvaluateContext;\n  isTriggerBased: boolean;\n  evalArguments?: Array<unknown>;\n  /*\n   Whether to remove functions like \"run\", \"clear\" from entities in global context\n   use case => To show lint warning when Api.run is used in a function bound to a data field (Eg. Button.text)\n   */\n  removeEntityFunctions?: boolean;\n}\n\n/**\n * overrideContext is a set of key-value pairs where they key is a path\n * and the value is any value.\n *\n * The purpose of overrideContext is to update the EVAL_CONTEXT's entity properties\n * with new value during runtime.\n * An example of runtime would be execution of a query where some parameters are passed\n * to the .run function.\n * This enables to override the entities and their values in EVAL_CONTEXT without any side-effects\n * to the actual dataTree since this is a non-persistent transient state of evaluation.\n *\n * Example:\n * overrideContext = {\n *  \"Input1.text\": \"hello\"\n * }\n * // before overriding\n * EVAL_CONTEXT = {\n *  \"Input1\": {\n *    \"text\": \"Hey!\"\n *  }\n * \"Text1\": {\n *    \"text\": \"YOLO\"\n *  }\n * }\n *\n * // after overriding just for the particular evaluation\n * EVAL_CONTEXT = {\n *  \"Input1\": {\n *    \"text\": \"Hello\"\n *  },\n * \"Text1\": {\n *  \"text\": \"YOLO\"\n * }\n *\n * Where is this overriding actually used?\n * At the time of writing this, the use case originated to evaluate run-time params of a\n * query module instance as pass them off as inputs.\n * Eg. QueryModule1.run({ input1: \"10\" }) and the bindings for this could be QueryModule1.inputs.input1\n * So the executionParams needs to be put in the EVAL_CONTEXT with the above path and the supplied value.\n * Therefore an overriding of the EVAL_CONTEXT is required during runtime execution.\n *\n * Why klona is used to cloned here?\n * Since EVAL_CONTEXT is build from the dataTree by adding the entities directly referentially\n * Eg. EVAL_CONTEXT[\"Input1\"] = dataTree[\"Input1\"]\n * Overriding the EVAL_CONTEXT directly using set(EVAL_CONTEXT, path, value); would mutate the dataTree\n * thus polluting the dataTree for the next evaluation.\n * To avoid this, all the unique entities of present in the overrideContext is identified and cloned once for\n * the particular entities only. This avoid unnecessary cloning of every entity and further multiple times.\n *\n */\nconst overrideEvalContext = (\n  EVAL_CONTEXT: EvalContext,\n  overrideContext?: Record<string, unknown>,\n) => {\n  if (overrideContext) {\n    const entitiesClonedSoFar = new Set();\n\n    Object.keys(overrideContext).forEach((path) => {\n      const { entityName } = getEntityNameAndPropertyPath(path);\n\n      if (entityName in EVAL_CONTEXT && !entitiesClonedSoFar.has(entityName)) {\n        entitiesClonedSoFar.add(entityName);\n        EVAL_CONTEXT[entityName] = klona(EVAL_CONTEXT[entityName]);\n      }\n    });\n\n    Object.entries(overrideContext).forEach(([path, value]) => {\n      set(EVAL_CONTEXT, path, value);\n    });\n  }\n};\n\n/**\n * This method created an object with dataTree and appsmith's framework actions that needs to be added to worker global scope for the JS code evaluation to then consume it.\n *\n * Example:\n * - For `eval(\"Table1.tableData\")` code to work as expected, we define Table1.tableData in worker global scope and for that we use `createEvaluationContext` to get the object to set in global scope.\n */\nexport const createEvaluationContext = (args: createEvaluationContextArgs) => {\n  const {\n    configTree = {},\n    context,\n    dataTree,\n    evalArguments,\n    isTriggerBased,\n    removeEntityFunctions,\n  } = args;\n\n  const EVAL_CONTEXT: EvalContext = {};\n\n  ///// Adding callback data\n  EVAL_CONTEXT.ARGUMENTS = evalArguments;\n  //// Adding contextual data not part of data tree\n  EVAL_CONTEXT.THIS_CONTEXT = context?.thisContext || {};\n\n  if (context?.globalContext) {\n    Object.assign(EVAL_CONTEXT, context.globalContext);\n  }\n\n  const dataTreeContext = getDataTreeContext({\n    dataTree,\n    configTree,\n    removeEntityFunctions: !!removeEntityFunctions,\n    isTriggerBased,\n  });\n\n  Object.assign(EVAL_CONTEXT, dataTreeContext);\n\n  overrideEvalContext(EVAL_CONTEXT, context?.overrideContext);\n\n  return EVAL_CONTEXT;\n};\n\nexport function sanitizeScript(js: string) {\n  // We remove any line breaks from the beginning of the script because that\n  // makes the final function invalid. We also unescape any escaped characters\n  // so that eval can happen\n  const trimmedJS = js.replace(beginsWithLineBreakRegex, \"\");\n\n  return self.evaluationVersion > 1 ? trimmedJS : unescapeJS(trimmedJS);\n}\n\n/** Define a context just for this script\n * thisContext will define it on the `this`\n * globalContext will define it globally\n * requestId is used for completing promises\n */\nexport interface EvaluateContext {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisContext?: Record<string, any>;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  globalContext?: Record<string, any>;\n  requestId?: string;\n  eventType?: EventType;\n  triggerMeta?: TriggerMeta;\n  overrideContext?: Record<string, unknown>;\n}\n\nexport const getUserScriptToEvaluate = (\n  userScript: string,\n  isTriggerBased: boolean,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>,\n) => {\n  const unescapedJS = sanitizeScript(userScript);\n\n  // If nothing is present to evaluate, return\n  if (!unescapedJS.length) {\n    return {\n      script: \"\",\n    };\n  }\n\n  const scriptType = getScriptType(!!evalArguments, isTriggerBased);\n  const script = getScriptToEval(unescapedJS, scriptType);\n\n  return { script };\n};\n\nexport function setEvalContext({\n  configTree,\n  context,\n  dataTree,\n  evalArguments,\n  isDataField,\n  isTriggerBased,\n}: {\n  context?: EvaluateContext;\n  dataTree: DataTree;\n  configTree?: ConfigTree;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>;\n  isDataField: boolean;\n  isTriggerBased: boolean;\n}) {\n  self[\"$isDataField\"] = isDataField;\n\n  const evalContext = createEvaluationContext({\n    dataTree,\n    configTree,\n    context,\n    evalArguments,\n    isTriggerBased,\n  });\n\n  Object.assign(self, evalContext);\n}\n\nexport function evaluateSync(\n  userScript: string,\n  dataTree: DataTree,\n  isJSCollection: boolean,\n  context?: EvaluateContext,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>,\n  configTree: ConfigTree = {},\n  evalContextCache?: EvalContext,\n): EvalResult {\n  return (function () {\n    const errors: EvaluationError[] = [];\n    let result;\n\n    const { script } = getUserScriptToEvaluate(\n      userScript,\n      false,\n      evalArguments,\n    );\n\n    // If nothing is present to evaluate, return instead of evaluating\n    if (!script.length) {\n      return {\n        errors: [],\n        result: undefined,\n        triggers: [],\n      };\n    }\n\n    self[\"$isDataField\"] = true;\n    const EVAL_CONTEXT: EvalContext = {};\n\n    ///// Adding callback data\n    EVAL_CONTEXT.ARGUMENTS = evalArguments;\n    //// Adding contextual data not part of data tree\n    EVAL_CONTEXT.THIS_CONTEXT = context?.thisContext || {};\n\n    if (context?.globalContext) {\n      Object.assign(EVAL_CONTEXT, context.globalContext);\n    }\n\n    if (evalContextCache) {\n      Object.assign(EVAL_CONTEXT, evalContextCache);\n    } else {\n      const dataTreeContext = getDataTreeContext({\n        dataTree,\n        configTree,\n        removeEntityFunctions: false,\n        isTriggerBased: isJSCollection,\n      });\n\n      Object.assign(EVAL_CONTEXT, dataTreeContext);\n    }\n\n    overrideEvalContext(EVAL_CONTEXT, context?.overrideContext);\n\n    Object.assign(self, EVAL_CONTEXT);\n\n    try {\n      result = indirectEval(script);\n\n      if (result instanceof Promise) {\n        /**\n         * If a promise is returned in data field then show the error to help understand data field doesn't await to resolve promise.\n         * NOTE: Awaiting for promise will make data field evaluation slower.\n         */\n        throw new FoundPromiseInSyncEvalError();\n      }\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      const { errorCategory, errorMessage, rootcause } = errorModifier.run(\n        error,\n        { userScript: error.userScript || userScript, source: error.source },\n        [ActionInDataFieldErrorModifier, TypeErrorModifier],\n      );\n\n      errors.push({\n        errorMessage,\n        severity: Severity.ERROR,\n        raw: script,\n        errorType: PropertyEvaluationErrorType.PARSE,\n        originalBinding: userScript,\n        kind: {\n          category: errorCategory,\n          rootcause,\n        },\n      });\n    } finally {\n      self[\"$isDataField\"] = false;\n    }\n\n    return { result, errors };\n  })();\n}\n\nexport async function evaluateAsync(\n  userScript: string,\n  dataTree: DataTree,\n  configTree: ConfigTree,\n  context?: EvaluateContext,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>,\n) {\n  return (async function () {\n    resetWorkerGlobalScope();\n    const errors: EvaluationError[] = [];\n    let result;\n\n    const { script } = getUserScriptToEvaluate(userScript, true, evalArguments);\n\n    setEvalContext({\n      dataTree,\n      configTree,\n      isDataField: false,\n      isTriggerBased: true,\n      context,\n      evalArguments,\n    });\n\n    try {\n      result = await indirectEval(script);\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      const { errorMessage } = errorModifier.run(\n        error,\n        { userScript: error.userScript || userScript, source: error.source },\n        [PrimitiveErrorModifier, TypeErrorModifier],\n      );\n\n      errors.push({\n        errorMessage: errorMessage,\n        severity: Severity.ERROR,\n        raw: script,\n        errorType: PropertyEvaluationErrorType.PARSE,\n        originalBinding: userScript,\n      });\n    } finally {\n      return {\n        result,\n        errors,\n      };\n    }\n  })();\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function shouldAddSetter(setter: any, entity: DataTreeEntity) {\n  const isDisabledExpression = setter.disabled;\n\n  if (!isDisabledExpression) return true;\n\n  const isDisabledFn = new Function(\"options\", isDisabledExpression);\n\n  return !isDisabledFn({ entity });\n}\n","/**\n * Why we need this?\n * By default Object.keys return values's type is flawed. It returns array of strings and because of that we lose the type information of the object\n * when looping through the keys. This function returns an array of keys with the correct type information.\n *\n * with classic Object.keys: Object.keys({ a: 1, b: 2 }) -> string[]\n * with objectKeys: objectKeys({ a: 1, b: 2 }) -> (\"a\" | \"b\")[]\n *\n * @param object\n * @returns array of keys with correct type information\n */\n\nexport function objectKeys<T extends object>(object: T): Array<keyof T> {\n  return Object.keys(object) as Array<keyof T>;\n}\n","import _ from \"lodash\";\n\nexport enum Types {\n  URL = \"URL\",\n  STRING = \"STRING\",\n  NUMBER = \"NUMBER\",\n  BOOLEAN = \"BOOLEAN\",\n  OBJECT = \"OBJECT\",\n  ARRAY = \"ARRAY\",\n  FUNCTION = \"FUNCTION\",\n  UNDEFINED = \"UNDEFINED\",\n  NULL = \"NULL\",\n  UNKNOWN = \"UNKNOWN\",\n}\n\nexport const getType = (value: unknown) => {\n  if (_.isString(value)) return Types.STRING;\n\n  if (_.isNumber(value)) return Types.NUMBER;\n\n  if (_.isBoolean(value)) return Types.BOOLEAN;\n\n  if (Array.isArray(value)) return Types.ARRAY;\n\n  if (_.isFunction(value)) return Types.FUNCTION;\n\n  if (_.isObject(value)) return Types.OBJECT;\n\n  if (_.isUndefined(value)) return Types.UNDEFINED;\n\n  if (_.isNull(value)) return Types.NULL;\n\n  return Types.UNKNOWN;\n};\n\nexport function isURL(str: string) {\n  const pattern = new RegExp(\n    \"^((blob:)?https?:\\\\/\\\\/)?\" + //protocol\n      \"((([a-z\\\\d]([a-z\\\\d-]*[a-z\\\\d])*)\\\\.)+[a-z]{2,}|\" + // domain name\n      \"((\\\\d{1,3}\\\\.){3}\\\\d{1,3}))\" + // OR ip (v4) address\n      \"(\\\\:\\\\d+)?(/[^?#]*)?\" + // port and path\n      \"(\\\\?[;&a-z\\\\d%_.~+=-]*)?\" + // query string\n      \"(\\\\#[-a-z\\\\d_]*)?$\",\n    \"i\",\n  ); // fragment locator\n\n  return !!pattern.test(str);\n}\n\nexport type TruthyPrimitiveTypes = number | string | boolean | bigint | symbol;\n","import type { Node, SourceLocation, Options, Comment } from \"acorn\";\nimport { parse } from \"acorn\";\nimport { ancestor, simple } from \"acorn-walk\";\nimport { ECMA_VERSION, NodeTypes } from \"./constants\";\nimport { has, isFinite, isNil, isString, toPath } from \"lodash\";\nimport { getStringValue, isTrueObject, sanitizeScript } from \"./utils\";\nimport { jsObjectDeclaration } from \"./jsObject\";\nimport { attachComments } from \"astravel\";\nimport { generate } from \"astring\";\n/*\n * Valuable links:\n *\n * * ESTree spec: Javascript AST is called ESTree.\n * Each es version has its md file in the repo to find features\n * implemented and their node type\n * https://github.com/estree/estree\n *\n * * Acorn: The parser we use to get the AST\n * https://github.com/acornjs/acorn\n *\n * * Acorn walk: The walker we use to traverse the AST\n * https://github.com/acornjs/acorn/tree/master/acorn-walk\n *\n * * AST Explorer: Helpful web tool to see ASTs and its parts\n * https://astexplorer.net/\n *\n */\n\ntype Pattern =\n  | IdentifierNode\n  | AssignmentPatternNode\n  | ArrayPatternNode\n  | ObjectPatternNode\n  | RestElementNode;\ntype Expression = Node;\nexport type ArgumentTypes =\n  | LiteralNode\n  | ArrowFunctionExpressionNode\n  | ObjectExpression\n  | MemberExpressionNode\n  | CallExpressionNode\n  | BinaryExpressionNode\n  | BlockStatementNode\n  | IdentifierNode;\n// doc: https://github.com/estree/estree/blob/master/es5.md#memberexpression\nexport interface MemberExpressionNode extends Node {\n  type: NodeTypes.MemberExpression;\n  object: MemberExpressionNode | IdentifierNode | CallExpressionNode;\n  property: IdentifierNode | LiteralNode;\n  computed: boolean;\n  // doc: https://github.com/estree/estree/blob/master/es2020.md#chainexpression\n  optional?: boolean;\n}\n\nexport interface BinaryExpressionNode extends Node {\n  type: NodeTypes.BinaryExpression;\n  left: BinaryExpressionNode | IdentifierNode;\n  right: BinaryExpressionNode | IdentifierNode;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#identifier\nexport interface IdentifierNode extends Node {\n  type: NodeTypes.Identifier;\n  name: string;\n}\n\nexport interface ArrayPatternNode extends Node {\n  type: NodeTypes.ArrayPattern;\n  elements: Array<Pattern | null>;\n}\n\nexport interface AssignmentProperty extends Node {\n  type: NodeTypes.Property;\n  key: Expression;\n  value: Pattern;\n  kind: \"init\";\n  method: false;\n  shorthand: boolean;\n  computed: boolean;\n}\n\nexport interface RestElementNode extends Node {\n  type: NodeTypes.RestElement;\n  argument: Pattern;\n}\n\nexport interface ObjectPatternNode extends Node {\n  type: NodeTypes.ObjectPattern;\n  properties: Array<AssignmentProperty | RestElementNode>;\n}\n\n//Using this to handle the Variable property refactor\ninterface RefactorIdentifierNode extends Node {\n  type: NodeTypes.Identifier;\n  name: string;\n  property?: IdentifierNode;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#variabledeclarator\ninterface VariableDeclaratorNode extends Node {\n  type: NodeTypes.VariableDeclarator;\n  id: IdentifierNode;\n  init: Expression | null;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#functions\ninterface Function extends Node {\n  id: IdentifierNode | null;\n  params: Pattern[];\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#functiondeclaration\ninterface FunctionDeclarationNode extends Node, Function {\n  type: NodeTypes.FunctionDeclaration;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#functionexpression\ninterface FunctionExpressionNode extends Expression, Function {\n  type: NodeTypes.FunctionExpression;\n  async: boolean;\n}\n\nexport interface ArrowFunctionExpressionNode extends Expression, Function {\n  type: NodeTypes.ArrowFunctionExpression;\n  async: boolean;\n}\n\nexport interface ObjectExpression extends Expression {\n  type: NodeTypes.ObjectExpression;\n  properties: Array<PropertyNode>;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es2015.md#assignmentpattern\ninterface AssignmentPatternNode extends Node {\n  type: NodeTypes.AssignmentPattern;\n  left: Pattern;\n  right: ArgumentTypes;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#literal\nexport interface LiteralNode extends Node {\n  type: NodeTypes.Literal;\n  value: string | boolean | null | number | RegExp;\n  raw: string;\n}\n\nexport interface CallExpressionNode extends Node {\n  type: NodeTypes.CallExpression;\n  callee: CallExpressionNode | IdentifierNode | MemberExpressionNode;\n  arguments: ArgumentTypes[];\n}\n\n// https://github.com/estree/estree/blob/master/es5.md#thisexpression\nexport interface ThisExpressionNode extends Expression {\n  type: \"ThisExpression\";\n}\n\n// https://github.com/estree/estree/blob/master/es5.md#conditionalexpression\nexport interface ConditionalExpressionNode extends Expression {\n  type: \"ConditionalExpression\";\n  test: Expression;\n  alternate: Expression;\n  consequent: Expression;\n}\n\n// https://github.com/estree/estree/blob/master/es2017.md#awaitexpression\nexport interface AwaitExpressionNode extends Expression {\n  type: \"AwaitExpression\";\n  argument: Expression;\n}\n\nexport interface BlockStatementNode extends Node {\n  type: \"BlockStatement\";\n  body: [Node];\n}\n\ninterface NodeList {\n  references: Set<string>;\n  functionalParams: Set<string>;\n  variableDeclarations: Set<string>;\n  identifierList: Array<IdentifierNode>;\n}\n\n// https://github.com/estree/estree/blob/master/es5.md#property\nexport interface PropertyNode extends Node {\n  type: NodeTypes.Property;\n  key: LiteralNode | IdentifierNode;\n  value: Node;\n  kind: \"init\" | \"get\" | \"set\";\n}\n\nexport interface ExpressionStatement extends Node {\n  type: \"ExpressionStatement\";\n  expression: Expression;\n}\n\nexport interface Program extends Node {\n  type: \"Program\";\n  body: [Directive | Statement];\n}\n\nexport type Statement = Node;\n\nexport interface Directive extends ExpressionStatement {\n  expression: LiteralNode;\n  directive: string;\n}\n\nexport interface ExportDefaultDeclarationNode extends Node {\n  declaration: Node;\n}\n\n// Node with location details\nexport type NodeWithLocation<NodeType> = NodeType & {\n  loc: SourceLocation;\n};\n\ntype AstOptions = Omit<Options, \"ecmaVersion\">;\n\ninterface EntityRefactorResponse {\n  isSuccess: boolean;\n  body: { script: string; refactorCount: number } | { error: string };\n}\n\n/* We need these functions to typescript casts the nodes with the correct types */\nexport const isIdentifierNode = (node: Node): node is IdentifierNode => {\n  return node.type === NodeTypes.Identifier;\n};\n\nexport const isMemberExpressionNode = (\n  node: Node,\n): node is MemberExpressionNode => {\n  return node.type === NodeTypes.MemberExpression;\n};\n\nexport const isThisExpressionNode = (\n  node: Node,\n): node is ThisExpressionNode => {\n  return node.type === NodeTypes.ThisExpression;\n};\n\nexport const isConditionalExpressionNode = (\n  node: Node,\n): node is ConditionalExpressionNode =>\n  node.type === NodeTypes.ConditionalExpression;\n\nexport const isAwaitExpressionNode = (\n  node: Node,\n): node is AwaitExpressionNode => node.type === NodeTypes.AwaitExpression;\n\nexport const isBinaryExpressionNode = (\n  node: Node,\n): node is BinaryExpressionNode => {\n  return node.type === NodeTypes.BinaryExpression;\n};\n\nexport const isVariableDeclarator = (\n  node: Node,\n): node is VariableDeclaratorNode => {\n  return node.type === NodeTypes.VariableDeclarator;\n};\n\nconst isFunctionDeclaration = (node: Node): node is FunctionDeclarationNode => {\n  return node.type === NodeTypes.FunctionDeclaration;\n};\n\nconst isFunctionExpression = (node: Node): node is FunctionExpressionNode => {\n  return node.type === NodeTypes.FunctionExpression;\n};\n\nexport const isArrowFunctionExpression = (\n  node: Node,\n): node is ArrowFunctionExpressionNode => {\n  return node.type === NodeTypes.ArrowFunctionExpression;\n};\n\nexport const isAssignmentExpression = (\n  node: Node,\n): node is AssignmentExpressionNode => {\n  return node.type === NodeTypes.AssignmentExpression;\n};\n\nexport const isObjectExpression = (node: Node): node is ObjectExpression => {\n  return node.type === NodeTypes.ObjectExpression;\n};\n\nconst isAssignmentPatternNode = (node: Node): node is AssignmentPatternNode => {\n  return node.type === NodeTypes.AssignmentPattern;\n};\n\nexport const isArrayPatternNode = (node: Node): node is ArrayPatternNode => {\n  return node.type === NodeTypes.ArrayPattern;\n};\n\nexport const isObjectPatternNode = (node: Node): node is ObjectPatternNode => {\n  return node.type === NodeTypes.ObjectPattern;\n};\n\nexport const isRestElementNode = (node: Node): node is RestElementNode => {\n  return node.type === NodeTypes.RestElement;\n};\n\nexport const isLiteralNode = (node: Node): node is LiteralNode => {\n  return node.type === NodeTypes.Literal;\n};\n\nexport const isPropertyNode = (node: Node): node is PropertyNode => {\n  return node.type === NodeTypes.Property;\n};\n\nexport const isCallExpressionNode = (\n  node: Node,\n): node is CallExpressionNode => {\n  return node.type === NodeTypes.CallExpression;\n};\n\nexport const isBlockStatementNode = (\n  node: Node,\n): node is BlockStatementNode => {\n  return node.type === NodeTypes.BlockStatement;\n};\n\nexport const isExpressionStatementNode = (\n  node: Node,\n): node is ExpressionStatement => {\n  return node.type === NodeTypes.ExpressionStatement;\n};\n\nexport const isExportDefaultDeclarationNode = (\n  node: Node,\n): node is ExportDefaultDeclarationNode => {\n  return node.type === NodeTypes.ExportDefaultDeclaration;\n};\n\nexport const isPropertyAFunctionNode = (\n  node: Node,\n): node is ArrowFunctionExpressionNode | FunctionExpressionNode => {\n  return (\n    node.type === NodeTypes.ArrowFunctionExpression ||\n    node.type === NodeTypes.FunctionExpression\n  );\n};\n\nconst isArrayAccessorNode = (node: Node): node is MemberExpressionNode => {\n  return (\n    isMemberExpressionNode(node) &&\n    node.computed &&\n    isLiteralNode(node.property) &&\n    isFinite(node.property.value)\n  );\n};\n\nexport const wrapCode = (code: string) => {\n  return `\n    (function() {\n      return ${code}\n    })\n  `;\n};\n\n//Tech-debt: should upgrade this to better logic\n//Used slice for a quick resolve of critical bug\nconst unwrapCode = (code: string) => {\n  const unwrapedCode = code.slice(32);\n\n  return unwrapedCode.slice(0, -10);\n};\n\nconst getFunctionalParamNamesFromNode = (\n  node:\n    | FunctionDeclarationNode\n    | FunctionExpressionNode\n    | ArrowFunctionExpressionNode,\n) => {\n  return Array.from(getFunctionalParamsFromNode(node)).map(\n    (functionalParam) => functionalParam.paramName,\n  );\n};\n\n// Memoize the ast generation code to improve performance.\n// Since this will be used by both the server and the client, we want to prevent regeneration of ast\n// for the the same code snippet\nexport const getAST = (code: string, options?: AstOptions) =>\n  parse(code, { ...options, ecmaVersion: ECMA_VERSION });\n\nexport const attachCommentsToAst = (\n  ast: Node,\n  commentArray: Array<Comment>,\n) => {\n  return attachComments(ast, commentArray);\n};\n/**\n * An AST based extractor that fetches all possible references in a given\n * piece of code. We use this to get any references to the global entities in Appsmith\n * and create dependencies on them. If the reference was updated, the given piece of code\n * should run again.\n * @param code: The piece of script where references need to be extracted from\n */\n\nexport interface IdentifierInfo {\n  references: string[];\n  functionalParams: string[];\n  variables: string[];\n  isError: boolean;\n}\nexport const extractIdentifierInfoFromCode = (\n  code: string,\n  evaluationVersion: number,\n  invalidIdentifiers?: Record<string, unknown>,\n): IdentifierInfo => {\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n\n  try {\n    const sanitizedScript = sanitizeScript(code, evaluationVersion);\n    /* wrapCode - Wrapping code in a function, since all code/script get wrapped with a function during evaluation.\n       Some syntax won't be valid unless they're at the RHS of a statement.\n       Since we're assigning all code/script to RHS during evaluation, we do the same here.\n       So that during ast parse, those errors are neglected.\n    */\n    /* e.g. IIFE without braces\n      function() { return 123; }() -> is invalid\n      let result = function() { return 123; }() -> is valid\n    */\n    const wrappedCode = wrapCode(sanitizedScript);\n\n    ast = getAST(wrappedCode);\n    const { functionalParams, references, variableDeclarations }: NodeList =\n      ancestorWalk(ast);\n    const referencesArr = Array.from(references).filter((reference) => {\n      // To remove references derived from declared variables and function params,\n      // We extract the topLevelIdentifier Eg. Api1.name => Api1\n      const topLevelIdentifier = toPath(reference)[0];\n\n      return !(\n        functionalParams.has(topLevelIdentifier) ||\n        variableDeclarations.has(topLevelIdentifier) ||\n        has(invalidIdentifiers, topLevelIdentifier)\n      );\n    });\n\n    return {\n      references: referencesArr,\n      functionalParams: Array.from(functionalParams),\n      variables: Array.from(variableDeclarations),\n      isError: false,\n    };\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      // Syntax error. Ignore and return empty list\n      return {\n        references: [],\n        functionalParams: [],\n        variables: [],\n        isError: true,\n      };\n    }\n\n    throw e;\n  }\n};\n\nexport const entityRefactorFromCode = (\n  script: string,\n  oldName: string,\n  newName: string,\n  isJSObject: boolean,\n  evaluationVersion: number,\n  invalidIdentifiers?: Record<string, unknown>,\n): EntityRefactorResponse => {\n  //Sanitizing leads to removal of special charater.\n  //Hence we are not sanatizing the script. Fix(#18492)\n  //If script is a JSObject then replace export default to decalartion.\n  if (isJSObject) script = jsObjectToCode(script);\n  else script = wrapCode(script);\n\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n  //Copy of script to refactor\n  let refactorScript = script;\n  //Difference in length of oldName and newName\n  const nameLengthDiff: number = newName.length - oldName.length;\n  //Offset index used for deciding location of oldName.\n  let refactorOffset = 0;\n  //Count of refactors on the script\n  let refactorCount = 0;\n\n  try {\n    ast = getAST(script);\n    const {\n      functionalParams,\n      identifierList,\n      references,\n      variableDeclarations,\n    }: NodeList = ancestorWalk(ast);\n    const identifierArray = Array.from(\n      identifierList,\n    ) as Array<RefactorIdentifierNode>;\n    //To handle if oldName has property (\"JSObject.myfunc\")\n    const oldNameArr = oldName.split(\".\");\n    const referencesArr = Array.from(references).filter((reference) => {\n      // To remove references derived from declared variables and function params,\n      // We extract the topLevelIdentifier Eg. Api1.name => Api1\n      const topLevelIdentifier = toPath(reference)[0];\n\n      return !(\n        functionalParams.has(topLevelIdentifier) ||\n        variableDeclarations.has(topLevelIdentifier) ||\n        has(invalidIdentifiers, topLevelIdentifier)\n      );\n    });\n\n    //Traverse through all identifiers in the script\n    identifierArray.forEach((identifier) => {\n      if (identifier.name === oldNameArr[0]) {\n        let index = 0;\n\n        while (index < referencesArr.length) {\n          if (identifier.name === referencesArr[index].split(\".\")[0]) {\n            //Replace the oldName by newName\n            //Get start index from node and get subarray from index 0 till start\n            //Append above with new name\n            //Append substring from end index from the node till end of string\n            //Offset variable is used to alter the position based on `refactorOffset`\n            //In case of nested JS action get end postion fro the property.\n            ///Default end index\n            let endIndex = identifier.end;\n            const propertyNode = identifier.property;\n            //Flag variable : true if property should be updated\n            //false if property should not be updated\n            const propertyCondFlag =\n              oldNameArr.length > 1 &&\n              propertyNode &&\n              oldNameArr[1] === propertyNode.name;\n\n            //Condition to validate if Identifier || Property should be updated??\n            if (oldNameArr.length === 1 || propertyCondFlag) {\n              //Condition to extend end index in case of property match\n              if (propertyCondFlag && propertyNode) {\n                endIndex = propertyNode.end;\n              }\n\n              refactorScript =\n                refactorScript.substring(0, identifier.start + refactorOffset) +\n                newName +\n                refactorScript.substring(endIndex + refactorOffset);\n              refactorOffset += nameLengthDiff;\n              ++refactorCount;\n              //We are only looking for one match in refrence for the identifier name.\n              break;\n            }\n          }\n\n          index++;\n        }\n      }\n    });\n\n    //If script is a JSObject then revert decalartion to export default.\n    if (isJSObject) refactorScript = jsCodeToObject(refactorScript);\n    else refactorScript = unwrapCode(refactorScript);\n\n    return {\n      isSuccess: true,\n      body: { script: refactorScript, refactorCount },\n    };\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      // Syntax error. Ignore and return empty list\n      return { isSuccess: false, body: { error: \"Syntax Error\" } };\n    }\n\n    throw e;\n  }\n};\n\nexport interface functionParam {\n  paramName: string;\n  defaultValue: unknown;\n}\n\nexport const getFunctionalParamsFromNode = (\n  node:\n    | FunctionDeclarationNode\n    | FunctionExpressionNode\n    | ArrowFunctionExpressionNode,\n  needValue = false,\n  code = \"\",\n): Set<functionParam> => {\n  const functionalParams = new Set<functionParam>();\n\n  node.params.forEach((paramNode) => {\n    if (isIdentifierNode(paramNode)) {\n      functionalParams.add({\n        paramName: paramNode.name,\n        defaultValue: undefined,\n      });\n    } else if (isAssignmentPatternNode(paramNode)) {\n      if (isIdentifierNode(paramNode.left)) {\n        const paramName = paramNode.left.name;\n\n        if (!needValue || !code) {\n          functionalParams.add({ paramName, defaultValue: undefined });\n        } else {\n          const defaultValueInString = code.slice(\n            paramNode.right.start,\n            paramNode.right.end,\n          );\n          const defaultValue =\n            paramNode.right.type === \"Literal\" &&\n            typeof paramNode.right.value === \"string\"\n              ? paramNode.right.value\n              : `{{${defaultValueInString}}}`;\n\n          functionalParams.add({\n            paramName,\n            defaultValue,\n          });\n        }\n      } else if (\n        isObjectPatternNode(paramNode.left) ||\n        isArrayPatternNode(paramNode.left)\n      ) {\n        functionalParams.add({\n          paramName: \"\",\n          defaultValue: undefined,\n        });\n      }\n      // The below computations are very basic and can be evolved into nested\n      // parsing logic to find param and it's default value.\n    } else if (isObjectPatternNode(paramNode)) {\n      functionalParams.add({\n        paramName: \"\",\n        defaultValue: `{{{}}}`,\n      });\n    } else if (isArrayPatternNode(paramNode)) {\n      functionalParams.add({\n        paramName: \"\",\n        defaultValue: \"{{[]}}\",\n      });\n    } else if (isRestElementNode(paramNode)) {\n      if (\"name\" in paramNode.argument) {\n        functionalParams.add({\n          paramName: paramNode.argument.name,\n          defaultValue: undefined,\n        });\n      }\n    }\n  });\n\n  return functionalParams;\n};\n\nconst constructFinalMemberExpIdentifier = (\n  node: MemberExpressionNode,\n  child = \"\",\n): string => {\n  const propertyAccessor = getPropertyAccessor(node.property);\n\n  if (isIdentifierNode(node.object)) {\n    return `${node.object.name}${propertyAccessor}${child}`;\n  } else {\n    const propertyAccessor = getPropertyAccessor(node.property);\n    const nestedChild = `${propertyAccessor}${child}`;\n\n    return constructFinalMemberExpIdentifier(\n      node.object as MemberExpressionNode,\n      nestedChild,\n    );\n  }\n};\n\nconst getPropertyAccessor = (propertyNode: IdentifierNode | LiteralNode) => {\n  if (isIdentifierNode(propertyNode)) {\n    return `.${propertyNode.name}`;\n  } else if (isLiteralNode(propertyNode) && isString(propertyNode.value)) {\n    // is string literal search a['b']\n    return `.${propertyNode.value}`;\n  } else if (isLiteralNode(propertyNode) && isFinite(propertyNode.value)) {\n    // is array index search - a[9]\n    return `[${propertyNode.value}]`;\n  }\n};\n\nexport const isTypeOfFunction = (type: string) => {\n  return (\n    type === NodeTypes.ArrowFunctionExpression ||\n    type === NodeTypes.FunctionExpression\n  );\n};\n\nexport interface MemberExpressionData {\n  property: NodeWithLocation<IdentifierNode | LiteralNode>;\n  object: NodeWithLocation<IdentifierNode>;\n}\n\nexport interface AssignmentExpressionData {\n  property: NodeWithLocation<IdentifierNode | LiteralNode>;\n  object: NodeWithLocation<IdentifierNode | MemberExpressionNode>;\n  parentNode: NodeWithLocation<AssignmentExpressionNode>;\n}\n\nexport interface CallExpressionData {\n  property: NodeWithLocation<IdentifierNode>;\n  params: NodeWithLocation<MemberExpressionNode | LiteralNode>[];\n}\n\n// This interface is used for storing call expression nodes with callee as member node\n// example of such case is when a function is called on object like obj.func()\n// This is required to understand whether appsmith.store.test.func() is present in script\n// in order to display mutation error on such statements.\nexport interface MemberCallExpressionData {\n  property: NodeWithLocation<MemberExpressionNode | LiteralNode>;\n  object: NodeWithLocation<MemberExpressionNode>;\n  parentNode: NodeWithLocation<CallExpressionNode>;\n}\n\nexport interface AssignmentExpressionNode extends Node {\n  operator: string;\n  left: Expression;\n  Right: Expression;\n}\n\n/** Function returns Invalid top-level member expressions from code\n * @param code\n * @param data\n * @param evaluationVersion\n * @returns information about all invalid property/method assessment in code\n * @example Given data {\n * JSObject1: {\n * name:\"JSObject\",\n * data:[]\n * },\n * Api1:{\n * name: \"Api1\",\n * data: []\n * }\n * },\n * For code {{Api1.name + JSObject.unknownProperty}}, function returns information about \"JSObject.unknownProperty\" node.\n */\nexport const extractExpressionsFromCode = (\n  code: string,\n  data: Record<string, any>,\n  evaluationVersion: number,\n): {\n  invalidTopLevelMemberExpressionsArray: MemberExpressionData[];\n  assignmentExpressionsData: AssignmentExpressionData[];\n  callExpressionsData: CallExpressionData[];\n  memberCallExpressionData: MemberCallExpressionData[];\n} => {\n  const assignmentExpressionsData = new Set<AssignmentExpressionData>();\n  const callExpressionsData = new Set<CallExpressionData>();\n  const memberCallExpressionData = new Set<MemberCallExpressionData>();\n  const invalidTopLevelMemberExpressions = new Set<MemberExpressionData>();\n  const variableDeclarations = new Set<string>();\n  let functionalParams = new Set<string>();\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n\n  try {\n    const sanitizedScript = sanitizeScript(code, evaluationVersion);\n    const wrappedCode = wrapCode(sanitizedScript);\n\n    ast = getAST(wrappedCode, { locations: true });\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      // Syntax error. Ignore and return empty list\n      return {\n        invalidTopLevelMemberExpressionsArray: [],\n        assignmentExpressionsData: [],\n        callExpressionsData: [],\n        memberCallExpressionData: [],\n      };\n    }\n\n    throw e;\n  }\n  simple(ast, {\n    MemberExpression(node: Node) {\n      const { computed, object, property } = node as MemberExpressionNode;\n\n      // We are only interested in top-level MemberExpression nodes\n      // Eg. for Api1.data.name, we are only interested in Api1.data\n      if (!isIdentifierNode(object)) return;\n\n      if (!(object.name in data) || !isTrueObject(data[object.name])) return;\n\n      // For computed member expressions (assessed via [], eg. JSObject1[\"name\"] ),\n      // We are only interested in strings\n      if (\n        isLiteralNode(property) &&\n        isString(property.value) &&\n        !(property.value in data[object.name])\n      ) {\n        invalidTopLevelMemberExpressions.add({\n          object,\n          property,\n        } as MemberExpressionData);\n      }\n\n      // We ignore computed member expressions if property is an identifier (JSObject[name])\n      // This is because we can't statically determine what the value of the identifier might be.\n      if (\n        isIdentifierNode(property) &&\n        !computed &&\n        !(property.name in data[object.name])\n      ) {\n        invalidTopLevelMemberExpressions.add({\n          object,\n          property,\n        } as MemberExpressionData);\n      }\n    },\n    VariableDeclarator(node: Node) {\n      if (isVariableDeclarator(node)) {\n        variableDeclarations.add(node.id.name);\n      }\n    },\n    FunctionDeclaration(node: Node) {\n      if (!isFunctionDeclaration(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    FunctionExpression(node: Node) {\n      if (!isFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    ArrowFunctionExpression(node: Node) {\n      if (!isArrowFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    AssignmentExpression(node: Node) {\n      if (\n        !isAssignmentExpression(node) ||\n        node.operator !== \"=\" ||\n        !isMemberExpressionNode(node.left)\n      )\n        return;\n\n      const { object, property } = node.left;\n\n      assignmentExpressionsData.add({\n        object,\n        property,\n        parentNode: node,\n      } as AssignmentExpressionData);\n    },\n    CallExpression(node: Node) {\n      if (isCallExpressionNode(node)) {\n        if (isIdentifierNode(node.callee)) {\n          callExpressionsData.add({\n            property: node.callee,\n            params: node.arguments,\n          } as CallExpressionData);\n        }\n\n        if (isMemberExpressionNode(node.callee)) {\n          const { object, property } = node.callee;\n\n          memberCallExpressionData.add({\n            object,\n            property,\n            parentNode: node,\n          } as MemberCallExpressionData);\n        }\n      }\n    },\n  });\n\n  const invalidTopLevelMemberExpressionsArray = Array.from(\n    invalidTopLevelMemberExpressions,\n  ).filter((MemberExpression) => {\n    return !(\n      variableDeclarations.has(MemberExpression.object.name) ||\n      functionalParams.has(MemberExpression.object.name)\n    );\n  });\n\n  return {\n    invalidTopLevelMemberExpressionsArray,\n    assignmentExpressionsData: [...assignmentExpressionsData],\n    callExpressionsData: [...callExpressionsData],\n    memberCallExpressionData: [...memberCallExpressionData],\n  };\n};\n\nconst ancestorWalk = (ast: Node): NodeList => {\n  //List of all Identifier nodes with their property(if exists).\n  const identifierList = new Array<RefactorIdentifierNode>();\n  // List of all references found\n  const references = new Set<string>();\n  // List of variables declared within the script. All identifiers and member expressions derived from declared variables will be removed\n  const variableDeclarations = new Set<string>();\n  // List of functional params declared within the script. All identifiers and member expressions derived from functional params will be removed\n  let functionalParams = new Set<string>();\n\n  /*\n   * We do an ancestor walk on the AST in order to extract all references. For example, for member expressions and identifiers, we need to know\n   * what surrounds the identifier (its parent and ancestors), ancestor walk will give that information in the callback\n   * doc: https://github.com/acornjs/acorn/tree/master/acorn-walk\n   */\n  ancestor(ast, {\n    Identifier(node: Node, ancestors: Node[]) {\n      /*\n       * We are interested in identifiers. Due to the nature of AST, Identifier nodes can\n       * also be nested inside MemberExpressions. For deeply nested object references, there\n       * could be nesting of many MemberExpressions. To find the final reference, we will\n       * try to find the top level MemberExpression that does not have a MemberExpression parent.\n       * */\n      let candidateTopLevelNode: IdentifierNode | MemberExpressionNode =\n        node as IdentifierNode;\n      let depth = ancestors.length - 2; // start \"depth\" with first parent\n\n      while (depth > 0) {\n        const parent = ancestors[depth];\n\n        if (\n          isMemberExpressionNode(parent) &&\n          /* Member expressions that are \"computed\" (with [ ] search)\n             and the ones that have optional chaining ( a.b?.c )\n             will be considered top level node.\n             We will stop looking for further parents */\n          /* \"computed\" exception - isArrayAccessorNode\n             Member expressions that are array accessors with static index - [9]\n             will not be considered top level.\n             We will continue looking further. */\n          (!parent.computed || isArrayAccessorNode(parent)) &&\n          !parent.optional\n        ) {\n          candidateTopLevelNode = parent;\n          depth = depth - 1;\n        } else {\n          // Top level found\n          break;\n        }\n      }\n\n      //If parent is a Member expression then attach property to the Node.\n      //else push Identifier Node.\n      const parentNode = ancestors[ancestors.length - 2];\n\n      if (isMemberExpressionNode(parentNode)) {\n        identifierList.push({\n          ...(node as IdentifierNode),\n          property: parentNode.property as IdentifierNode,\n        });\n      } else identifierList.push(node as RefactorIdentifierNode);\n\n      if (isIdentifierNode(candidateTopLevelNode)) {\n        // If the node is an Identifier, just save that\n        references.add(candidateTopLevelNode.name);\n      } else {\n        // For MemberExpression Nodes, we will construct a final reference string and then add\n        // it to the references list\n        const memberExpIdentifier = constructFinalMemberExpIdentifier(\n          candidateTopLevelNode,\n        );\n\n        references.add(memberExpIdentifier);\n      }\n    },\n    VariableDeclarator(node: Node) {\n      // keep a track of declared variables so they can be\n      // removed from the final list of references\n      if (isVariableDeclarator(node)) {\n        variableDeclarations.add(node.id.name);\n      }\n    },\n    FunctionDeclaration(node: Node) {\n      // params in function declarations are also counted as references so we keep\n      // track of them and remove them from the final list of references\n      if (!isFunctionDeclaration(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    FunctionExpression(node: Node) {\n      // params in function expressions are also counted as references so we keep\n      // track of them and remove them from the final list of references\n      if (!isFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    ArrowFunctionExpression(node: Node) {\n      // params in arrow function expressions are also counted as references so we keep\n      // track of them and remove them from the final list of references\n      if (!isArrowFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n  });\n\n  return {\n    references,\n    functionalParams,\n    variableDeclarations,\n    identifierList,\n  };\n};\n\n//Replace export default by a variable declaration.\n//This is required for acorn to parse code into AST.\nconst jsObjectToCode = (script: string) => {\n  return script.replace(/export default/g, jsObjectDeclaration);\n};\n\n//Revert the string replacement from 'jsObjectToCode'.\n//variable declaration is replaced back by export default.\nconst jsCodeToObject = (script: string) => {\n  return script.replace(jsObjectDeclaration, \"export default\");\n};\n\nexport const isFunctionPresent = (\n  script: string,\n  evaluationVersion: number,\n) => {\n  try {\n    const sanitizedScript = sanitizeScript(script, evaluationVersion);\n    const ast = getAST(sanitizedScript, {\n      locations: true,\n      ranges: true,\n    });\n\n    let isFunction = false;\n\n    simple(ast, {\n      FunctionDeclaration() {\n        isFunction = true;\n      },\n      FunctionExpression() {\n        isFunction = true;\n      },\n      ArrowFunctionExpression() {\n        isFunction = true;\n      },\n    });\n\n    return isFunction;\n  } catch (e) {\n    return false;\n  }\n};\n\nexport function getMemberExpressionObjectFromProperty(\n  propertyName: string,\n  code: string,\n  evaluationVersion = 2,\n) {\n  if (!propertyName) return [];\n\n  const memberExpressionObjects = new Set<string>();\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n\n  try {\n    const sanitizedScript = sanitizeScript(code, evaluationVersion);\n    const wrappedCode = wrapCode(sanitizedScript);\n\n    ast = getAST(wrappedCode, { locations: true });\n    simple(ast, {\n      MemberExpression(node: Node) {\n        const { object, property } = node as MemberExpressionNode;\n\n        if (!isLiteralNode(property) && !isIdentifierNode(property)) return;\n\n        const propName = isLiteralNode(property)\n          ? property.value\n          : property.name;\n\n        if (!isNil(propName) && getStringValue(propName) === propertyName) {\n          const memberExpressionObjectString = generate(object);\n\n          memberExpressionObjects.add(memberExpressionObjectString);\n        }\n      },\n    });\n\n    return Array.from(memberExpressionObjects);\n  } catch (e) {\n    return [];\n  }\n}\n","import type { Diff } from \"deep-diff\";\nimport { get, isArray, isEmpty, set } from \"lodash\";\nexport const UPDATES = \"propertyUpdates\";\nexport const REPLAY_DELAY = 300;\nexport const REPLAY_FOCUS_DELAY = 100;\nexport const TOASTS = \"toasts\";\nexport const FOCUSES = \"needsFocus\";\nexport const WIDGETS = \"widgets\";\n\n/**\n * checks the existing value and sets he propertyUpdate if required\n *\n * @param replay\n * @param path\n * @param value\n * @returns\n */\nexport // TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setPropertyUpdate(replay: any, path: string[], value: string[]) {\n  const existingPathValue = get(replay, path);\n\n  if (!existingPathValue || existingPathValue.length > 2) {\n    set(replay, path, value);\n    set(replay, UPDATES, true);\n  }\n}\n\n/**\n * pushes value to array element in array of objects\n *\n * @param obj\n * @param key\n * @param value\n * @returns\n */\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function addToArray(obj: any, key: string, value: any) {\n  if (!obj) return;\n\n  if (obj[key] && Array.isArray(obj[key])) {\n    obj[key].push(value);\n  } else {\n    obj[key] = [value];\n  }\n}\n\n/**\n * creates paths changed from diffs  array\n *\n * @param diffs\n * @returns\n */\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getPathsFromDiff(diffs: Array<Diff<any, any>>) {\n  const paths = [];\n\n  for (const diff of diffs) {\n    if (!diff.path || !Array.isArray(diff.path)) continue;\n\n    paths.push(diff.path.join(\".\"));\n  }\n\n  return paths;\n}\n\n/**\n * creates paths changed from diffs  array\n *\n * @param path\n * @returns\n */\nexport function pathArrayToString(path?: string[]) {\n  let stringPath = \"\";\n\n  if (!path || path.length === 0) return stringPath;\n\n  stringPath = path[0];\n\n  for (let i = 1; i < path.length; i++) {\n    stringPath += isNaN(parseInt(path[i])) ? `.${path[i]}` : `[${path[i]}]`;\n  }\n\n  return stringPath;\n}\n\n/**\n * Retrieves field config and parent section using the config property\n *\n * @param config\n * @param field\n * @param parentSection\n * @returns\n */\nexport // TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction findFieldInfo(config: Array<any>, field: string, parentSection = \"\") {\n  let result = {};\n\n  if (!config || !isArray(config)) return result;\n\n  for (const conf of config) {\n    if (conf.configProperty === field) {\n      result = { conf, parentSection };\n      break;\n    } else if (conf.children) {\n      parentSection = conf.sectionName || parentSection;\n      result = findFieldInfo(conf.children, field, parentSection);\n\n      if (!isEmpty(result)) break;\n    }\n  }\n\n  return result;\n}\n","import type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  DataTreeDiffEvent,\n  getEntityNameAndPropertyPath,\n  isJSAction,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  EXECUTION_PARAM_REFERENCE_REGEX,\n  THIS_DOT_PARAMS_KEY,\n} from \"constants/AppsmithActionConstants/ActionConstants\";\nimport type {\n  ConfigTree,\n  DataTree,\n  UnEvalTree,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type DependencyMap from \"entities/DependencyMap\";\nimport type { TJSPropertiesState } from \"workers/Evaluation/JSObject/jsPropertiesState\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport type {\n  DataTreeEntityConfig,\n  DataTreeEntityObject,\n  JSActionEntity,\n} from \"ee/entities/DataTree/types\";\nimport { isObject } from \"lodash\";\n\nimport type { AffectedJSObjects } from \"actions/EvaluationReduxActionTypes\";\n\nexport function getFixedTimeDifference(endTime: number, startTime: number) {\n  return (endTime - startTime).toFixed(2) + \" ms\";\n}\nexport function isDataField(fullPath: string, configTree: ConfigTree) {\n  const { entityName, propertyPath } = getEntityNameAndPropertyPath(fullPath);\n  const entityConfig = configTree[entityName];\n\n  if (entityConfig && \"triggerPaths\" in entityConfig) {\n    return !(propertyPath in entityConfig.triggerPaths);\n  }\n\n  return false;\n}\n\nexport function replaceThisDotParams(code: string) {\n  return code.replace(EXECUTION_PARAM_REFERENCE_REGEX, THIS_DOT_PARAMS_KEY);\n}\n\nexport function getAllAsyncJSFunctions(\n  unevalTree: DataTree,\n  jsPropertiesState: TJSPropertiesState,\n  dependencyMap: DependencyMap,\n  allAsyncNodes: string[],\n) {\n  const allAsyncJSFunctions: string[] = [];\n\n  for (const [entityName, entity] of Object.entries(unevalTree)) {\n    if (!isJSAction(entity)) continue;\n\n    const jsEntityState = jsPropertiesState[entityName];\n\n    if (!jsEntityState) continue;\n\n    for (const [propertyName, propertyState] of Object.entries(jsEntityState)) {\n      if (!(\"isMarkedAsync\" in propertyState)) continue;\n\n      if (propertyState.isMarkedAsync) {\n        allAsyncJSFunctions.push(`${entityName}.${propertyName}`);\n        continue;\n      } else {\n        const reacheableAsyncNodes = dependencyMap.getAllReachableNodes(\n          `${entityName}.${propertyName}`,\n          allAsyncNodes,\n        );\n\n        reacheableAsyncNodes.length &&\n          allAsyncJSFunctions.push(`${entityName}.${propertyName}`);\n      }\n    }\n  }\n\n  return allAsyncJSFunctions;\n}\n\nexport function isValidEntity(\n  entity: DataTreeEntity,\n): entity is DataTreeEntityObject {\n  if (!isObject(entity)) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function getValidEntityType(\n  entity: DataTreeEntity,\n  entityConfig: DataTreeEntityConfig,\n) {\n  let entityType;\n\n  if (isValidEntity(entity)) {\n    entityType =\n      (!!entityConfig && entityConfig.ENTITY_TYPE) || entity.ENTITY_TYPE;\n  }\n\n  return !!entityType ? entityType : \"noop\";\n}\n\n// in this function we are filtering out only the JSObjects that are affected by the changes\n// through this we limit the number of JSObjects that are diffed\nexport function getOnlyAffectedJSObjects(\n  jsDataTree: Record<string, JSActionEntity>,\n  affectedJSObjects: AffectedJSObjects,\n) {\n  const { ids, isAllAffected } = affectedJSObjects;\n\n  if (isAllAffected) {\n    return jsDataTree;\n  }\n\n  if (!ids || ids.length === 0) {\n    return {};\n  }\n\n  const idsSet = new Set(ids);\n\n  return Object.keys(jsDataTree).reduce(\n    (acc, jsObjectName) => {\n      const { actionId } = jsDataTree[jsObjectName];\n\n      //only matching action id will be included in the reduced jsDataTree\n      if (idsSet.has(actionId)) {\n        acc[jsObjectName] = jsDataTree[jsObjectName];\n      }\n\n      return acc;\n    },\n    {} as Record<string, JSActionEntity>,\n  );\n}\n\nexport function getIsNewWidgetAdded(\n  translatedDiffs: DataTreeDiff[],\n  unEvalTree: UnEvalTree,\n) {\n  return translatedDiffs.some((diffEvent) => {\n    if (diffEvent.event === DataTreeDiffEvent.NEW) {\n      const entity = unEvalTree[diffEvent.payload.propertyPath];\n\n      if (isWidget(entity)) {\n        return true;\n      }\n    }\n\n    return false;\n  });\n}\n","import type { ValidationConfig } from \"constants/PropertyControlConstants\";\nimport { Severity } from \"entities/AppsmithConsole\";\nimport type {\n  WidgetEntity,\n  WidgetEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport type { ConfigTree } from \"entities/DataTree/dataTreeTypes\";\nimport type { EvaluationError } from \"utils/DynamicBindingUtils\";\nimport {\n  isPathDynamicTrigger,\n  PropertyEvaluationErrorType,\n} from \"utils/DynamicBindingUtils\";\nimport {\n  addErrorToEntityProperty,\n  getEntityNameAndPropertyPath,\n  resetValidationErrorsForEntityProperty,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport { validate } from \"workers/Evaluation/validations\";\nimport type { EvalProps } from \".\";\nimport type { ValidationResponse } from \"constants/WidgetValidation\";\n\nexport function validateAndParseWidgetProperty({\n  configTree,\n  evalPropertyValue,\n  evalProps,\n  fullPropertyPath,\n  unEvalPropertyValue,\n  widget,\n}: {\n  fullPropertyPath: string;\n  widget: WidgetEntity;\n  configTree: ConfigTree;\n  evalPropertyValue: unknown;\n  unEvalPropertyValue: string;\n  evalProps: EvalProps;\n}): unknown {\n  const { propertyPath } = getEntityNameAndPropertyPath(fullPropertyPath);\n\n  if (isPathDynamicTrigger(widget, propertyPath)) {\n    // TODO find a way to validate triggers\n    return unEvalPropertyValue;\n  }\n\n  const widgetConfig = configTree[widget.widgetName] as WidgetEntityConfig;\n  const validation = widgetConfig.validationPaths[propertyPath];\n\n  const { isValid, messages, parsed } = validateWidgetProperty(\n    validation,\n    evalPropertyValue,\n    widget,\n    propertyPath,\n  );\n\n  // remove already present validation errors\n  resetValidationErrorsForEntityProperty({\n    evalProps,\n    fullPropertyPath,\n  });\n\n  if (!isValid) {\n    const evalErrors: EvaluationError[] =\n      messages?.map((message) => {\n        return {\n          raw: unEvalPropertyValue,\n          errorMessage: message || {},\n          errorType: PropertyEvaluationErrorType.VALIDATION,\n          severity: Severity.ERROR,\n        };\n      }) ?? [];\n\n    // Add validation errors\n    addErrorToEntityProperty({\n      errors: evalErrors,\n      evalProps,\n      fullPropertyPath,\n      configTree,\n    });\n  }\n\n  return parsed;\n}\n\nexport function validateWidgetProperty(\n  config: ValidationConfig,\n  value: unknown,\n  props: Record<string, unknown>,\n  propertyPath: string,\n) {\n  if (!config) {\n    return {\n      isValid: true,\n      parsed: value,\n    };\n  }\n\n  return validate(config, value, props, propertyPath);\n}\n\nexport function validateActionProperty(\n  config: ValidationConfig,\n  value: unknown,\n): ValidationResponse {\n  if (!config) {\n    return {\n      isValid: true,\n      parsed: value,\n    };\n  }\n\n  return validate(config, value, {}, \"\");\n}\n","export enum EVAL_WORKER_SYNC_ACTION {\n  SETUP = \"SETUP\",\n  EVAL_ACTION_BINDINGS = \"EVAL_ACTION_BINDINGS\",\n  CLEAR_CACHE = \"CLEAR_CACHE\",\n  VALIDATE_PROPERTY = \"VALIDATE_PROPERTY\",\n  UNDO = \"undo\",\n  REDO = \"redo\",\n  UPDATE_REPLAY_OBJECT = \"UPDATE_REPLAY_OBJECT\",\n  SET_EVALUATION_VERSION = \"SET_EVALUATION_VERSION\",\n  INIT_FORM_EVAL = \"INIT_FORM_EVAL\",\n  UNINSTALL_LIBRARY = \"UNINSTALL_LIBRARY\",\n  LINT_TREE = \"LINT_TREE\",\n  UPDATE_ACTION_DATA = \"UPDATE_ACTION_DATA\",\n  EVAL_TREE_WITH_CHANGES = \"EVAL_TREE_WITH_CHANGES\",\n}\n\nexport enum EVAL_WORKER_ASYNC_ACTION {\n  EVAL_TREE = \"EVAL_TREE\",\n  EVAL_TRIGGER = \"EVAL_TRIGGER\",\n  EVAL_EXPRESSION = \"EVAL_EXPRESSION\",\n  LOAD_LIBRARIES = \"LOAD_LIBRARIES\",\n  INSTALL_LIBRARY = \"INSTALL_LIBRARY\",\n}\n\nexport const EVAL_WORKER_ACTIONS = {\n  ...EVAL_WORKER_SYNC_ACTION,\n  ...EVAL_WORKER_ASYNC_ACTION,\n};\n\nexport enum MAIN_THREAD_ACTION {\n  PROCESS_TRIGGER = \"PROCESS_TRIGGER\",\n  PROCESS_BATCHED_TRIGGERS = \"PROCESS_BATCHED_TRIGGERS\",\n  PROCESS_STORE_UPDATES = \"PROCESS_STORE_UPDATES\",\n  PROCESS_LOGS = \"PROCESS_LOGS\",\n  LINT_TREE = \"LINT_TREE\",\n  PROCESS_JS_FUNCTION_EXECUTION = \"PROCESS_JS_FUNCTION_EXECUTION\",\n  UPDATE_DATATREE = \"UPDATE_DATATREE\",\n  SET_META_PROP_FROM_SETTER = \"SET_META_PROP_FROM_SETTER\",\n}\n","import type { DataTree } from \"entities/DataTree/dataTreeTypes\";\n\nexport interface GenerateOverrideContextProps {\n  bindings: string[];\n  dataTree: DataTree;\n  executionParams: Record<string, unknown>;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction generateOverrideContext(props: GenerateOverrideContextProps) {\n  return {};\n}\n\nexport default generateOverrideContext;\n","export * from \"ce/workers/Evaluation/generateOverrideContext\";\nimport { default as CE_generateOverrideContext } from \"ce/workers/Evaluation/generateOverrideContext\";\nexport default CE_generateOverrideContext;\n","import { get, isEmpty, isUndefined, set } from \"lodash\";\nimport type { JSActionEntity } from \"ee/entities/DataTree/types\";\nimport type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { EvalErrorTypes, getEvalValuePath } from \"utils/DynamicBindingUtils\";\nimport type { JSUpdate, ParsedJSSubAction } from \"utils/JSPaneUtils\";\nimport { parseJSObject, isJSFunctionProperty } from \"@shared/ast\";\nimport type DataTreeEvaluator from \"workers/common/DataTreeEvaluator\";\nimport { evaluateSync } from \"workers/Evaluation/evaluate\";\nimport type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  DataTreeDiffEvent,\n  getEntityNameAndPropertyPath,\n  isJSAction,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  removeFunctionsAndVariableJSCollection,\n  updateJSCollectionInUnEvalTree,\n} from \"workers/Evaluation/JSObject/utils\";\nimport { dataTreeEvaluator } from \"../handlers/evalTree\";\nimport JSObjectCollection from \"./Collection\";\nimport ExecutionMetaData from \"../fns/utils/ExecutionMetaData\";\nimport { jsPropertiesState } from \"./jsPropertiesState\";\nimport { getFixedTimeDifference } from \"workers/common/DataTreeEvaluator/utils\";\n\n/**\n * Here we update our unEvalTree according to the change in JSObject's body\n *\n * @param jsUpdates\n * @param localUnEvalTree\n * @returns\n */\nexport const getUpdatedLocalUnEvalTreeAfterJSUpdates = (\n  jsUpdates: Record<string, JSUpdate>,\n  localUnEvalTree: DataTree,\n  configTree: ConfigTree,\n) => {\n  if (!isEmpty(jsUpdates)) {\n    Object.entries(jsUpdates).forEach(([entityName, jsEntity]) => {\n      const entity = localUnEvalTree[entityName] as JSActionEntity;\n      const parsedBody = jsEntity.parsedBody;\n\n      if (isJSAction(entity)) {\n        if (!!parsedBody) {\n          //add/delete/update functions from dataTree\n          localUnEvalTree = updateJSCollectionInUnEvalTree(\n            parsedBody,\n            entity,\n            localUnEvalTree,\n            configTree,\n            entityName,\n          );\n        } else {\n          //if parse error remove functions and variables from dataTree\n          localUnEvalTree = removeFunctionsAndVariableJSCollection(\n            localUnEvalTree,\n            entity,\n            entityName,\n            configTree,\n          );\n        }\n      }\n    });\n  }\n\n  return localUnEvalTree;\n};\n\nexport const validJSBodyRegex = new RegExp(/^export default[\\s]*?({[\\s\\S]*?})/);\n\n/**\n * Here we parse the JSObject and then determine\n * 1. it's nature : async or sync\n * 2. Find arguments of JS Actions\n *\n * @param dataTreeEvalRef\n * @param entity\n * @param jsUpdates\n * @param unEvalDataTree\n * @param entityName\n * @returns\n */\nexport function saveResolvedFunctionsAndJSUpdates(\n  dataTreeEvalRef: DataTreeEvaluator,\n  entity: JSActionEntity,\n  jsUpdates: Record<string, JSUpdate>,\n  unEvalDataTree: DataTree,\n  entityName: string,\n) {\n  jsPropertiesState.delete(entityName);\n  const correctFormat =\n    entity.hasOwnProperty(\"body\") &&\n    !isUndefined(entity.body) &&\n    validJSBodyRegex.test(entity.body);\n  const isEmptyBody =\n    entity.hasOwnProperty(\"body\") &&\n    !isUndefined(entity.body) &&\n    entity?.body.trim() === \"\";\n\n  if (!isUndefined(entity.body) && (correctFormat || isEmptyBody)) {\n    try {\n      JSObjectCollection.deleteResolvedFunction(entityName);\n      JSObjectCollection.deleteUnEvalState(entityName);\n      JSObjectCollection.clearCachedVariablesForEvaluationContext(entityName);\n\n      const parseStartTime = performance.now();\n      const { parsedObject, success } = parseJSObject(entity.body);\n      const parseEndTime = performance.now();\n      const JSObjectASTParseTime = getFixedTimeDifference(\n        parseEndTime,\n        parseStartTime,\n      );\n\n      dataTreeEvalRef.logs.push({\n        JSObjectName: entityName,\n        JSObjectASTParseTime,\n      });\n\n      const actionsMap: Record<string, ParsedJSSubAction> = {};\n      const variablesMap: Record<string, { name: string; value: unknown }> = {};\n\n      if (success) {\n        if (!!parsedObject) {\n          jsPropertiesState.update(entityName, parsedObject);\n          parsedObject.forEach((parsedElement) => {\n            if (isJSFunctionProperty(parsedElement)) {\n              if (actionsMap[parsedElement.key]) return;\n\n              try {\n                ExecutionMetaData.setExecutionMetaData({\n                  enableJSVarUpdateTracking: false,\n                  enableJSFnPostProcessors: false,\n                });\n                const { result } = evaluateSync(\n                  parsedElement.value,\n                  unEvalDataTree,\n                  false,\n                );\n\n                ExecutionMetaData.setExecutionMetaData({\n                  enableJSVarUpdateTracking: true,\n                  enableJSFnPostProcessors: true,\n                });\n\n                if (!!result) {\n                  let params: Array<{ name: string; value: unknown }> = [];\n\n                  if (parsedElement.arguments) {\n                    params = parsedElement.arguments.map(\n                      ({ defaultValue, paramName }) => ({\n                        name: paramName,\n                        value: defaultValue,\n                      }),\n                    );\n                  }\n\n                  const functionString = parsedElement.value;\n\n                  JSObjectCollection.updateResolvedFunctions(\n                    `${entityName}.${parsedElement.key}`,\n                    result,\n                  );\n                  JSObjectCollection.updateUnEvalState(\n                    `${entityName}.${parsedElement.key}`,\n                    functionString,\n                  );\n                  actionsMap[parsedElement.key] = {\n                    name: parsedElement.key,\n                    body: functionString,\n                    arguments: params,\n                  };\n                }\n              } catch {\n                // in case we need to handle error state\n              }\n            } else if (parsedElement.type !== \"literal\") {\n              // when a jsobject property is of the type \"prop1\" or 'prop1', ast outputs the\n              // key as \"\\\"prop1\\\"\" or \"\\'prop1\\'\". We need to remove the extra quotes.\n              const isStringRepresentation =\n                parsedElement.key.startsWith(\"'\") ||\n                parsedElement.key.startsWith('\"');\n              const parsedKey = isStringRepresentation\n                ? parsedElement.key.slice(1, -1)\n                : parsedElement.key;\n\n              variablesMap[parsedKey] = {\n                name: parsedKey,\n                value: parsedElement.value,\n              };\n              JSObjectCollection.updateUnEvalState(\n                `${entityName}.${parsedElement.key}`,\n                parsedElement.value,\n              );\n            }\n          });\n          const parsedBody = {\n            body: entity.body,\n            actions: Object.values(actionsMap),\n            variables: Object.values(variablesMap),\n          };\n\n          set(jsUpdates, `${entityName}`, {\n            parsedBody,\n            id: entity.actionId,\n          });\n        } else {\n          set(jsUpdates, `${entityName}`, {\n            parsedBody: undefined,\n            id: entity.actionId,\n          });\n        }\n      }\n    } catch (e) {\n      //if we need to push error as popup in case\n    }\n  } else {\n    const parsedBody = {\n      body: entity.body,\n      actions: [],\n      variables: [],\n    };\n\n    set(jsUpdates, `${entityName}`, {\n      parsedBody: parsedBody,\n      id: entity.actionId,\n    });\n  }\n\n  if (!correctFormat && !isUndefined(entity.body)) {\n    const errors = {\n      type: EvalErrorTypes.PARSE_JS_ERROR,\n      context: {\n        entity: entity,\n        propertyPath: entityName + \".body\",\n      },\n      message: \"Start object with export default\",\n    };\n\n    dataTreeEvalRef.errors.push(errors);\n  }\n\n  return jsUpdates;\n}\n\nexport function parseJSActions(\n  dataTreeEvalRef: DataTreeEvaluator,\n  unEvalDataTree: DataTree,\n  oldUnEvalTree?: DataTree,\n  differences?: DataTreeDiff[],\n) {\n  const resolvedFunctions = JSObjectCollection.getResolvedFunctions();\n  const unEvalState = JSObjectCollection.getUnEvalState();\n  let jsUpdates: Record<string, JSUpdate> = {};\n\n  if (!!differences && !!oldUnEvalTree) {\n    differences.forEach((diff) => {\n      const { entityName, propertyPath } = getEntityNameAndPropertyPath(\n        diff.payload.propertyPath,\n      );\n      const entity = unEvalDataTree[entityName];\n\n      if (!isJSAction(entity)) return false;\n\n      if (diff.event === DataTreeDiffEvent.DELETE) {\n        // when JSObject is deleted, we remove it from currentJSCollectionState & resolvedFunctions\n        if (unEvalState && unEvalState[diff.payload.propertyPath]) {\n          JSObjectCollection.deleteUnEvalState(diff.payload.propertyPath);\n        }\n\n        if (resolvedFunctions && resolvedFunctions[diff.payload.propertyPath]) {\n          JSObjectCollection.deleteResolvedFunction(diff.payload.propertyPath);\n        }\n      }\n\n      if (\n        (diff.event === DataTreeDiffEvent.EDIT && propertyPath === \"body\") ||\n        (diff.event === DataTreeDiffEvent.NEW && propertyPath === \"\")\n      ) {\n        jsUpdates = saveResolvedFunctionsAndJSUpdates(\n          dataTreeEvalRef,\n          entity,\n          jsUpdates,\n          unEvalDataTree,\n          entityName,\n        );\n      }\n    });\n  } else {\n    Object.keys(unEvalDataTree).forEach((entityName) => {\n      const entity = unEvalDataTree[entityName];\n\n      if (!isJSAction(entity)) {\n        return;\n      }\n\n      jsUpdates = saveResolvedFunctionsAndJSUpdates(\n        dataTreeEvalRef,\n        entity,\n        jsUpdates,\n        unEvalDataTree,\n        entityName,\n      );\n    });\n  }\n\n  Object.keys(jsUpdates).forEach((entityName) => {\n    const parsedBody = jsUpdates[entityName].parsedBody;\n\n    if (!parsedBody) return;\n\n    parsedBody.actions = parsedBody.actions.map((action) => {\n      return {\n        ...action,\n      } as ParsedJSSubAction;\n    });\n  });\n\n  return { jsUpdates };\n}\n\nexport function getJSEntities(dataTree: DataTree) {\n  const jsCollections: Record<string, JSActionEntity> = {};\n\n  Object.keys(dataTree).forEach((entityName: string) => {\n    const entity = dataTree[entityName];\n\n    if (isJSAction(entity)) {\n      jsCollections[entityName] = entity;\n    }\n  });\n\n  return jsCollections;\n}\n\nexport function updateEvalTreeWithJSCollectionState(evalTree: DataTree) {\n  // loop through jsCollectionState and set all values to evalTree\n  const jsCollections = JSObjectCollection.getVariableState();\n  const jsCollectionEntries = Object.entries(jsCollections);\n\n  for (const [jsObjectName, variableState] of jsCollectionEntries) {\n    if (!evalTree[jsObjectName]) continue;\n\n    evalTree[jsObjectName] = Object.assign(\n      evalTree[jsObjectName],\n      variableState,\n    );\n  }\n}\n\nexport function updateEvalTreeValueFromContext(paths: string[][]) {\n  const currentEvalContext = self;\n\n  if (!dataTreeEvaluator) return;\n\n  const evalTree = dataTreeEvaluator.getEvalTree();\n\n  for (const fullPathArray of paths) {\n    const [jsObjectName, variableName] = fullPathArray;\n    const entity = evalTree[jsObjectName];\n\n    if (jsObjectName && variableName && isJSAction(entity)) {\n      if (!(jsObjectName in currentEvalContext)) continue;\n\n      const variableValue = get(currentEvalContext, [\n        jsObjectName,\n        variableName,\n      ]);\n      const value = variableValue;\n\n      JSObjectCollection.setVariableValue(\n        value,\n        `${jsObjectName}.${variableName}`,\n      );\n      /*\n      JSobject variable values are picked from evalProps until the unevalValue is not modified.\n      Hence, we need to set the value in evalProps to ensure it doesn't have stale values.\n      */\n      set(\n        dataTreeEvaluator.evalProps,\n        getEvalValuePath(`${jsObjectName}.${variableName}`, {\n          isPopulated: true,\n          fullPath: true,\n        }),\n        value,\n      );\n    }\n  }\n}\n","import ExecutionMetaData from \"../utils/ExecutionMetaData\";\n\nconst _internalSetInterval = self.setInterval;\nconst _internalClearInterval = self.clearInterval;\n\nconst intervalIdMap = new Map<number | string, number>();\n\nexport function clearAllIntervals() {\n  intervalIdMap.forEach((intervalId) => _internalClearInterval(intervalId));\n  intervalIdMap.clear();\n}\n\nexport function clearInterval(intervalId: number | string) {\n  const runningIntervalId = intervalIdMap.get(intervalId);\n\n  intervalIdMap.delete(intervalId);\n\n  return _internalClearInterval(runningIntervalId);\n}\n\nexport function setInterval(\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  callback: (...args: any[]) => void,\n  delay = 300,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ...args: any[]\n) {\n  const metaData = ExecutionMetaData.getExecutionMetaData();\n  const runningIntervalId = intervalIdMap.get(args[0]);\n\n  if (runningIntervalId) {\n    _internalClearInterval(runningIntervalId);\n    intervalIdMap.delete(args[0]);\n  }\n\n  const _internalIntervalId = _internalSetInterval(\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (...args: any[]) => {\n      self[\"$isDataField\"] = false;\n      ExecutionMetaData.setExecutionMetaData(metaData);\n      typeof callback === \"function\" && callback(...args);\n    },\n    delay,\n    ...args,\n  );\n  const customIntervalId = args[0] || _internalIntervalId;\n\n  intervalIdMap.set(customIntervalId, _internalIntervalId);\n\n  return _internalIntervalId;\n}\n","export * from \"ce/entities/Engine/actionHelpers\";\nimport type { CreateNewActionKey } from \"ce/entities/Engine/actionHelpers\";\nimport { ActionParentEntityType as CE_ActionParentEntityType } from \"ce/entities/Engine/actionHelpers\";\n\nexport type CreateNewActionKeyInterface =\n  (typeof CreateNewActionKey)[keyof typeof CreateNewActionKey];\n\nexport const ActionParentEntityType = {\n  ...CE_ActionParentEntityType,\n};\n\nexport type ActionParentEntityTypeInterface =\n  (typeof ActionParentEntityType)[keyof typeof ActionParentEntityType];\n","import type { Diff } from \"deep-diff\";\nimport type { CanvasWidgetsReduxState } from \"ee/reducers/entityReducers/canvasWidgetsReducer\";\nimport ReplayEntity from \"../index\";\nimport { set } from \"lodash\";\nimport {\n  addToArray,\n  FOCUSES,\n  setPropertyUpdate,\n  TOASTS,\n  UPDATES,\n  WIDGETS,\n} from \"../replayUtils\";\nimport type { AppTheme } from \"entities/AppTheming\";\nimport { ENTITY_TYPE } from \"ee/entities/AppsmithConsole/utils\";\n\nexport interface Canvas {\n  widgets: CanvasWidgetsReduxState;\n  theme: AppTheme;\n}\nexport type CanvasDiff = Diff<Canvas, Canvas>;\nexport type DSLDiff = Diff<CanvasWidgetsReduxState, CanvasWidgetsReduxState>;\n\nconst positionProps = [\n  \"leftColumn\",\n  \"rightColumn\",\n  \"topRow\",\n  \"bottomRow\",\n  \"minHeight\",\n  \"parentColumnSpace\",\n  \"parentRowSpace\",\n  \"children\",\n  \"parentId\",\n  \"renderMode\",\n  \"detachFromLayout\",\n  \"noContainerOffset\",\n  \"isCanvas\",\n  \"height\",\n];\n\n/**\n * checks property changed is a positional property\n *\n * @param widgetProperty\n * @returns\n */\nfunction isPositionUpdate(widgetProperty: string) {\n  return positionProps.indexOf(widgetProperty) !== -1;\n}\n\nexport default class ReplayCanvas extends ReplayEntity<Canvas> {\n  public constructor(entity: Canvas) {\n    super(entity, ENTITY_TYPE.WIDGET);\n  }\n\n  /**\n   * process the diff\n   *\n   * @param diff\n   * @param replay\n   * @param isUndo\n   * @returns\n   */\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public processDiff(diff: CanvasDiff, replay: any, isUndo: boolean) {\n    if (!diff || !diff.path || !diff.path.length || diff.path[1] === \"0\")\n      return;\n\n    if (diff.path.indexOf(\"widgets\") > -1) {\n      return this.processDiffForWidgets(diff, replay, isUndo);\n    }\n\n    if (diff.path.indexOf(\"theme\") > -1) {\n      return this.processDiffForTheme(diff, replay);\n    }\n  }\n\n  /**\n   * process diff related to app theming\n   *\n   * @param diff\n   * @param replay\n   * @param isUndo\n   */\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public processDiffForTheme(diff: CanvasDiff, replay: any) {\n    if (!diff || !diff.path || !diff.path.length || diff.path[1] === \"0\")\n      return;\n\n    set(replay, \"theme\", true);\n\n    if (diff.path.join(\".\") === \"theme.name\") {\n      set(replay, \"themeChanged\", true);\n    }\n  }\n\n  /**\n   * process diffs related to DSL ( widgets )\n   *\n   * @param diff\n   * @param replay\n   * @param isUndo\n   * @returns\n   */\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public processDiffForWidgets(diff: CanvasDiff, replay: any, isUndo: boolean) {\n    if (!diff || !diff.path || !diff.path.length || diff.path[1] === \"0\")\n      return;\n\n    const widgetId = diff.path[1];\n\n    switch (diff.kind) {\n      // new elements is added in dsl\n      case \"N\":\n        if (diff.path.length == 2) {\n          const toast = this.createToast(\n            diff.rhs,\n            this.entity.widgets[widgetId],\n            widgetId,\n            isUndo,\n            !isUndo,\n          );\n\n          addToArray(replay, TOASTS, toast);\n        } else {\n          setPropertyUpdate(replay, [WIDGETS, widgetId, UPDATES], diff.path);\n        }\n\n        break;\n      // element is deleted in dsl\n      case \"D\":\n        if (diff.path.length == 2) {\n          const toast = this.createToast(\n            diff.lhs,\n            this.entity.widgets[widgetId],\n            widgetId,\n            isUndo,\n            isUndo,\n          );\n\n          addToArray(replay, TOASTS, toast);\n        } else {\n          setPropertyUpdate(replay, [WIDGETS, widgetId, UPDATES], diff.path);\n        }\n\n        break;\n      // element is edited\n      case \"E\":\n        if (isPositionUpdate(diff.path[diff.path.length - 2])) {\n          set(replay, [WIDGETS, widgetId, FOCUSES], true);\n        } else {\n          setPropertyUpdate(replay, [WIDGETS, widgetId, UPDATES], diff.path);\n        }\n\n        break;\n      default:\n        break;\n    }\n  }\n\n  private createToast(\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    diffWidget: any,\n    dslWidget: CanvasWidgetsReduxState | undefined,\n    widgetId: string,\n    isUndo: boolean,\n    isCreated: boolean,\n  ) {\n    const widgetName = isCreated\n      ? diffWidget.widgetName\n      : dslWidget?.widgetName;\n\n    return {\n      isCreated,\n      isUndo,\n      widgetName,\n      widgetId,\n    };\n  }\n}\n","import { getType, Types } from \"utils/TypeHelpers\";\nimport _ from \"lodash\";\nimport { EvaluationSubstitutionType } from \"ee/entities/DataTree/types\";\nimport { isDynamicValue } from \"utils/DynamicBindingUtils\";\nimport { QUOTED_BINDING_REGEX } from \"constants/BindingsConstants\";\n\nconst filterBindingSegmentsAndRemoveQuotes = (\n  binding: string,\n  subSegments: string[],\n  subSegmentValues: unknown[],\n) => {\n  const bindingStrippedQuotes = binding.replace(\n    QUOTED_BINDING_REGEX,\n    (original, firstGroup) => {\n      return firstGroup;\n    },\n  );\n  const subBindings: string[] = [];\n  const subValues: unknown[] = [];\n\n  subSegments.forEach((segment, i) => {\n    if (isDynamicValue(segment)) {\n      subBindings.push(segment);\n      subValues.push(subSegmentValues[i]);\n    }\n  });\n\n  return { binding: bindingStrippedQuotes, subBindings, subValues };\n};\n\nexport const smartSubstituteDynamicValues = (\n  originalBinding: string,\n  subSegments: string[],\n  subSegmentValues: unknown[],\n): string => {\n  const { binding, subBindings, subValues } =\n    filterBindingSegmentsAndRemoveQuotes(\n      originalBinding,\n      subSegments,\n      subSegmentValues,\n    );\n  let finalBinding = binding;\n\n  subBindings.forEach((b, i) => {\n    const value = subValues[i];\n\n    switch (getType(value)) {\n      case Types.NUMBER:\n      case Types.BOOLEAN:\n      case Types.NULL:\n      case Types.UNDEFINED:\n        // Direct substitution\n        finalBinding = finalBinding.replace(b, `${value}`);\n        break;\n      case Types.STRING:\n        // Add quotes to a string\n        // JSON.stringify string to escape any unsupported characters\n        finalBinding = finalBinding.replace(b, `${JSON.stringify(value)}`);\n        break;\n      case Types.ARRAY:\n      case Types.OBJECT:\n        // Stringify and substitute\n        finalBinding = finalBinding.replace(b, JSON.stringify(value, null, 2));\n        break;\n    }\n  });\n\n  return finalBinding;\n};\n\nexport const parameterSubstituteDynamicValues = (\n  originalBinding: string,\n  subSegments: string[],\n  subSegmentValues: unknown[],\n) => {\n  const { binding, subBindings, subValues } =\n    filterBindingSegmentsAndRemoveQuotes(\n      originalBinding,\n      subSegments,\n      subSegmentValues,\n    );\n\n  // if only one binding is provided in the whole string, we need to throw an error\n  if (subSegments.length === 1 && subBindings.length === 1) {\n    throw Error(\n      \"Dynamic bindings in prepared statements are only used to provide parameters inside SQL query. No SQL query found.\",\n    );\n  }\n\n  let finalBinding = binding;\n  const parameters: Record<string, unknown> = {};\n\n  subBindings.forEach((b, i) => {\n    // Replace binding with $1, $2;\n    const key = `$${i + 1}`;\n\n    finalBinding = finalBinding.replace(b, key);\n    parameters[key] =\n      typeof subValues[i] === \"object\"\n        ? JSON.stringify(subValues[i], null, 2)\n        : subValues[i];\n  });\n\n  return { value: finalBinding, parameters };\n};\n// For creating a final value where bindings could be in a template format\nexport const templateSubstituteDynamicValues = (\n  binding: string,\n  subBindings: string[],\n  subValues: unknown[],\n): string => {\n  // Replace the string with the data tree values\n  let finalValue = binding;\n\n  subBindings.forEach((b, i) => {\n    let value = subValues[i];\n\n    if (Array.isArray(value) || _.isObject(value)) {\n      value = JSON.stringify(value);\n    }\n\n    try {\n      if (typeof value === \"string\" && JSON.parse(value)) {\n        value = value.replace(/\\\\([\\s\\S])|(\")/g, \"\\\\$1$2\");\n      }\n    } catch (e) {\n      // do nothing\n    }\n    finalValue = finalValue.replace(b, `${value}`);\n  });\n\n  return finalValue;\n};\n\nexport const substituteDynamicBindingWithValues = (\n  binding: string,\n  subSegments: string[],\n  subSegmentValues: unknown[],\n  evaluationSubstitutionType: EvaluationSubstitutionType,\n): string | { value: string; parameters: Record<string, unknown> } => {\n  switch (evaluationSubstitutionType) {\n    case EvaluationSubstitutionType.TEMPLATE:\n      return templateSubstituteDynamicValues(\n        binding,\n        subSegments,\n        subSegmentValues,\n      );\n    case EvaluationSubstitutionType.SMART_SUBSTITUTE:\n      return smartSubstituteDynamicValues(\n        binding,\n        subSegments,\n        subSegmentValues,\n      );\n    case EvaluationSubstitutionType.PARAMETER:\n      return parameterSubstituteDynamicValues(\n        binding,\n        subSegments,\n        subSegmentValues,\n      );\n  }\n};\n","import {\n  addWidgetPropertyDependencies,\n  getEntityNameAndPropertyPath,\n  isATriggerPath,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport type {\n  ActionEntity,\n  ActionEntityConfig,\n  JSActionEntity,\n  JSActionEntityConfig,\n  DataTreeEntityConfig,\n  WidgetEntity,\n  WidgetEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { find, union } from \"lodash\";\nimport { getEntityDynamicBindingPathList } from \"utils/DynamicBindingUtils\";\nimport type { DataTreeEntityObject } from \"ee/entities/DataTree/types\";\nimport { getDependencyFromEntityPath } from \"workers/common/DependencyMap/utils/getEntityDependencies\";\n\nexport const getDependencies = {\n  [ENTITY_TYPE.ACTION]: (\n    entity: DataTreeEntityObject,\n    entityConfig: DataTreeEntityConfig,\n    allKeys: Record<string, true>,\n  ) => {\n    return getActionDependencies(\n      entity as ActionEntity,\n      entityConfig as ActionEntityConfig,\n      allKeys,\n    );\n  },\n  [ENTITY_TYPE.JSACTION]: (\n    entity: DataTreeEntityObject,\n    entityConfig: DataTreeEntityConfig,\n    allKeys: Record<string, true>,\n  ) => {\n    return getJSDependencies(\n      entity as JSActionEntity,\n      entityConfig as JSActionEntityConfig,\n      allKeys,\n    );\n  },\n  [ENTITY_TYPE.WIDGET]: (\n    entity: DataTreeEntityObject,\n    entityConfig: DataTreeEntityConfig,\n  ) => {\n    return getWidgetDependencies(\n      entity as WidgetEntity,\n      entityConfig as WidgetEntityConfig,\n    );\n  },\n};\n\nexport function getWidgetDependencies(\n  widgetEntity: WidgetEntity,\n  widgetConfig: WidgetEntityConfig,\n): Record<string, string[]> {\n  const widgetName = widgetEntity.widgetName;\n  const dependencies: Record<string, string[]> = addWidgetPropertyDependencies({\n    widgetConfig,\n    widgetName,\n  });\n\n  const dependencyMap = widgetConfig.dependencyMap;\n\n  for (const source in dependencyMap) {\n    if (!dependencyMap.hasOwnProperty(source)) continue;\n\n    const targetPaths = dependencyMap[source];\n    const fullPropertyPath = `${widgetName}.${source}`;\n\n    dependencies[fullPropertyPath] = dependencies[fullPropertyPath] || [];\n    dependencies[fullPropertyPath].push(\n      ...targetPaths.map((p) => `${widgetName}.${p}`),\n    );\n  }\n\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(widgetConfig);\n  const dynamicTriggerPathList = widgetConfig.dynamicTriggerPathList || [];\n\n  for (const { key } of dynamicTriggerPathList) {\n    dependencies[`${widgetName}.${key}`] = [];\n  }\n\n  for (const bindingPath of dynamicBindingPathList) {\n    const propertyPath = bindingPath.key;\n    const fullPropertyPath = `${widgetName}.${propertyPath}`;\n    const dynamicPathDependencies = getDependencyFromEntityPath(\n      propertyPath,\n      widgetEntity,\n    );\n    const existingDeps = dependencies[fullPropertyPath] || [];\n    const newDeps = union(existingDeps, dynamicPathDependencies);\n\n    dependencies[fullPropertyPath] = newDeps;\n  }\n\n  return dependencies;\n}\nexport function getJSDependencies(\n  jsEntity: JSActionEntity,\n  jsActionConfig: JSActionEntityConfig,\n  allKeys: Record<string, true>,\n): Record<string, string[]> {\n  let dependencies: Record<string, string[]> = {};\n  const jsActionReactivePaths = jsActionConfig.reactivePaths || {};\n  const jsActionDependencyMap = jsActionConfig.dependencyMap || {};\n  const jsObjectName = jsActionConfig.name || \"\";\n\n  for (const [propertyPath, pathDeps] of Object.entries(\n    jsActionDependencyMap,\n  )) {\n    const fullPropertyPath = `${jsObjectName}.${propertyPath}`;\n    const propertyPathDependencies: string[] = pathDeps\n      .map((dependentPath) => `${jsObjectName}.${dependentPath}`)\n      .filter((path) => allKeys.hasOwnProperty(path));\n\n    dependencies[fullPropertyPath] = propertyPathDependencies;\n  }\n\n  for (const reactivePath of Object.keys(jsActionReactivePaths)) {\n    const fullPropertyPath = `${jsObjectName}.${reactivePath}`;\n    const reactivePathDependencies = getDependencyFromEntityPath(\n      reactivePath,\n      jsEntity,\n    );\n    const existingDeps = dependencies[fullPropertyPath] || [];\n    const newDeps = union(existingDeps, reactivePathDependencies);\n\n    dependencies = { ...dependencies, [fullPropertyPath]: newDeps };\n  }\n\n  return dependencies;\n}\nexport function getActionDependencies(\n  actionEntity: ActionEntity,\n  actionConfig: ActionEntityConfig,\n  allKeys: Record<string, true>,\n): Record<string, string[]> {\n  let dependencies: Record<string, string[]> = {};\n  const actionName = actionConfig.name;\n  const actionDependencyMap = actionConfig.dependencyMap || {};\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(actionConfig);\n\n  for (const [propertyPath, pathDeps] of Object.entries(actionDependencyMap)) {\n    const fullPropertyPath = `${actionName}.${propertyPath}`;\n    const propertyPathDependencies: string[] = pathDeps\n      .map((dependentPath) => `${actionName}.${dependentPath}`)\n      .filter((path) => allKeys.hasOwnProperty(path));\n\n    dependencies[fullPropertyPath] = propertyPathDependencies;\n  }\n\n  for (const dynamicPath of dynamicBindingPathList) {\n    const propertyPath = dynamicPath.key;\n    const fullPropertyPath = `${actionName}.${propertyPath}`;\n    const dynamicPathDependencies = getDependencyFromEntityPath(\n      propertyPath,\n      actionEntity,\n    );\n    const existingDeps = dependencies[fullPropertyPath] || [];\n    const newDependencies = union(existingDeps, dynamicPathDependencies);\n\n    dependencies = { ...dependencies, [fullPropertyPath]: newDependencies };\n  }\n\n  return dependencies;\n}\n\nexport const getPathDependencies = {\n  [ENTITY_TYPE.ACTION]: (\n    entity: DataTreeEntity,\n    entityConfig: DataTreeEntityConfig,\n    fullPropertyPath: string,\n    allKeys: Record<string, true>,\n  ) => {\n    return getActionPropertyPathDependencies(\n      entity as ActionEntity,\n      entityConfig as ActionEntityConfig,\n      fullPropertyPath,\n      allKeys,\n    );\n  },\n  [ENTITY_TYPE.JSACTION]: (\n    entity: DataTreeEntity,\n    entityConfig: DataTreeEntityConfig,\n    fullPropertyPath: string,\n    allKeys: Record<string, true>,\n  ) => {\n    return getJSPropertyPathDependencies(\n      entity as JSActionEntity,\n      entityConfig as JSActionEntityConfig,\n      fullPropertyPath,\n      allKeys,\n    );\n  },\n  [ENTITY_TYPE.WIDGET]: (\n    entity: DataTreeEntity,\n    entityConfig: DataTreeEntityConfig,\n    fullPropertyPath: string,\n  ) => {\n    return getWidgetPropertyPathDependencies(\n      entity as WidgetEntity,\n      entityConfig as WidgetEntityConfig,\n      fullPropertyPath,\n    );\n  },\n};\n\nfunction getWidgetPropertyPathDependencies(\n  widgetEntity: WidgetEntity,\n  widgetConfig: WidgetEntityConfig,\n  fullPropertyPath: string,\n) {\n  let dependencies: string[] = [];\n  const { propertyPath } = getEntityNameAndPropertyPath(fullPropertyPath);\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(widgetConfig);\n  const bindingPaths = widgetConfig.bindingPaths || {};\n  const widgetInternalDependencies = addWidgetPropertyDependencies({\n    widgetConfig,\n    widgetName: widgetEntity.widgetName,\n  });\n  const widgetPathInternalDependencies =\n    widgetInternalDependencies[fullPropertyPath];\n\n  dependencies = union(dependencies, widgetPathInternalDependencies);\n\n  if (isATriggerPath(widgetConfig, propertyPath)) return dependencies;\n\n  const isPathADynamicPath =\n    bindingPaths.hasOwnProperty(propertyPath) ||\n    find(dynamicBindingPathList, { key: propertyPath });\n\n  if (!isPathADynamicPath) return dependencies;\n\n  const dynamicPathDependencies = getDependencyFromEntityPath(\n    propertyPath,\n    widgetEntity,\n  );\n\n  dependencies = union(dependencies, dynamicPathDependencies);\n\n  return dependencies;\n}\n\nfunction getJSPropertyPathDependencies(\n  jsEntity: JSActionEntity,\n  jsActionConfig: JSActionEntityConfig,\n  fullPropertyPath: string,\n  allKeys: Record<string, true>,\n) {\n  const { propertyPath } = getEntityNameAndPropertyPath(fullPropertyPath);\n  const jsActionReactivePaths = jsActionConfig.reactivePaths || {};\n  let dependencies: string[] = [];\n  const jsInternalDependencyMap = jsActionConfig.dependencyMap || {};\n  const jsPathInternalDependencies =\n    jsInternalDependencyMap[propertyPath]\n      ?.map((dep) => `${jsActionConfig.name}.${dep}`)\n      ?.filter((path) => allKeys.hasOwnProperty(path)) || [];\n\n  dependencies = union(dependencies, jsPathInternalDependencies);\n\n  if (jsActionReactivePaths.hasOwnProperty(propertyPath)) {\n    const propertyPathDependencies = getDependencyFromEntityPath(\n      propertyPath,\n      jsEntity,\n    );\n\n    dependencies = union(dependencies, propertyPathDependencies);\n  }\n\n  return dependencies;\n}\n\nfunction getActionPropertyPathDependencies(\n  actionEntity: ActionEntity,\n  actionConfig: ActionEntityConfig,\n  fullPropertyPath: string,\n  allKeys: Record<string, true>,\n) {\n  let actionPathDependencies: string[] = [];\n  const { propertyPath } = getEntityNameAndPropertyPath(fullPropertyPath);\n  const actionInternalDependencyMap = actionConfig.dependencyMap || {};\n  const actionPathInternalDependencies =\n    actionInternalDependencyMap[propertyPath]\n      ?.map((dep) => `${actionConfig.name}.${dep}`)\n      .filter((path) => allKeys.hasOwnProperty(path)) || [];\n\n  actionPathDependencies = union(\n    actionPathDependencies,\n    actionPathInternalDependencies,\n  );\n\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(actionConfig);\n  const bindingPaths = actionConfig.bindingPaths;\n\n  const isADynamicPath =\n    bindingPaths.hasOwnProperty(propertyPath) ||\n    find(dynamicBindingPathList, { key: propertyPath });\n\n  if (!isADynamicPath) return actionPathDependencies;\n\n  const dynamicPathDependencies = getDependencyFromEntityPath(\n    propertyPath,\n    actionEntity,\n  );\n\n  actionPathDependencies = union(\n    actionPathDependencies,\n    dynamicPathDependencies,\n  );\n\n  return actionPathDependencies;\n}\n","import type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { get } from \"lodash\";\nimport { getDynamicBindings } from \"utils/DynamicBindingUtils\";\nimport { isWidgetActionOrJsObject } from \"ee/entities/DataTree/utils\";\nimport type { DataTreeEntityObject } from \"ee/entities/DataTree/types\";\nimport {\n  getDependencies,\n  getPathDependencies,\n} from \"ee/workers/common/DependencyMap/utils/getEntityDependenciesByType\";\nimport type { DataTreeEntityConfig } from \"ee/entities/DataTree/types\";\n\nexport function getEntityDependencies(\n  entity: DataTreeEntityObject,\n  entityConfig: DataTreeEntityConfig,\n  allKeys: Record<string, true>,\n): Record<string, string[]> {\n  if (!isWidgetActionOrJsObject(entity)) return {};\n\n  return (\n    getDependencies[entity.ENTITY_TYPE](\n      entity as DataTreeEntityObject,\n      entityConfig as DataTreeEntityConfig,\n      allKeys as Record<string, true>,\n    ) || {}\n  );\n}\n\nexport function getEntityPathDependencies(\n  entity: DataTreeEntity,\n  entityConfig: DataTreeEntityConfig,\n  fullPropertyPath: string,\n  allKeys: Record<string, true>,\n) {\n  if (!isWidgetActionOrJsObject(entity)) return [];\n\n  return (\n    getPathDependencies[entity.ENTITY_TYPE](\n      entity as DataTreeEntity,\n      entityConfig as DataTreeEntityConfig,\n      fullPropertyPath as string,\n      allKeys as Record<string, true>,\n    ) || []\n  );\n}\n\nexport function getDependencyFromEntityPath(\n  propertyPath: string,\n  entity: DataTreeEntity,\n) {\n  const unevalPropValue = get(entity, propertyPath, \"\").toString();\n  const { jsSnippets } = getDynamicBindings(unevalPropValue, entity);\n  const validJSSnippets = jsSnippets.filter((jsSnippet) => !!jsSnippet);\n\n  return validJSSnippets;\n}\n","import toposort from \"toposort\";\nimport type DependencyMap from \".\";\nimport { IMMEDIATE_PARENT_REGEX } from \"ee/workers/Evaluation/evaluationUtils\";\n\ntype SortDependencies =\n  | {\n      success: true;\n      sortedDependencies: string[];\n    }\n  | { success: false; cyclicNode: string; error: unknown };\n\nexport class DependencyMapUtils {\n  // inspired by https://www.npmjs.com/package/toposort#sorting-dependencies\n  static sortDependencies(dependencyMap: DependencyMap): SortDependencies {\n    const dependencyTree: Array<[string, string | undefined]> = [];\n    const dependencies = dependencyMap.rawDependencies;\n\n    for (const [node, deps] of dependencies.entries()) {\n      if (deps.size) {\n        deps.forEach((dep) => dependencyTree.push([node, dep]));\n      } else {\n        // Set no dependency\n        dependencyTree.push([node, undefined]);\n      }\n    }\n\n    try {\n      const sortedDependencies = toposort(dependencyTree)\n        .reverse()\n        .filter((edge) => !!edge);\n\n      return { success: true, sortedDependencies };\n    } catch (error) {\n      // Cyclic dependency found. Extract node\n      const cyclicNodes = (error as Error).message.match(\n        new RegExp('Cyclic dependency, node was:\"(.*)\"'),\n      );\n      const node = cyclicNodes ? cyclicNodes[1] : \"\";\n\n      return { success: false, cyclicNode: node, error };\n    }\n  }\n  // this function links childNode to its parent as a dependency for the entire dependencyGraph\n  static makeParentsDependOnChildren(dependencyMap: DependencyMap) {\n    const dependencies = dependencyMap.rawDependencies;\n\n    for (const [node, deps] of dependencies.entries()) {\n      this.makeParentsDependOnChild(dependencyMap, node);\n      deps.forEach((dep) => {\n        this.makeParentsDependOnChild(dependencyMap, dep);\n      });\n    }\n\n    return dependencyMap;\n  }\n\n  // this function links childNode to its parent as a dependency for only affectedNodes in the graph\n  static linkAffectedChildNodesToParent(\n    dependencyMap: DependencyMap,\n    affectedSet: Set<string>,\n  ) {\n    const dependencies = dependencyMap.rawDependencies;\n\n    for (const [node, deps] of dependencies.entries()) {\n      if (affectedSet.has(node)) {\n        DependencyMapUtils.makeParentsDependOnChild(dependencyMap, node);\n      }\n\n      deps.forEach((dep) => {\n        if (affectedSet.has(dep)) {\n          DependencyMapUtils.makeParentsDependOnChild(dependencyMap, dep);\n        }\n      });\n    }\n\n    return dependencyMap;\n  }\n\n  static makeParentsDependOnChild = (\n    dependencyMap: DependencyMap,\n    child: string,\n  ) => {\n    let curKey = child;\n    let matches: string[] | null;\n\n    while ((matches = curKey.match(IMMEDIATE_PARENT_REGEX)) !== null) {\n      const immediateParent = matches[1];\n      const existingImmediateParentDeps =\n        dependencyMap.getDirectDependencies(immediateParent) || [];\n      const existingImmediateParentDepsSet = new Set(\n        existingImmediateParentDeps,\n      );\n\n      // Add child to immediate parent's dependencies if not already present\n      // don't perform addDependency unnecessarily\n      if (!existingImmediateParentDepsSet.has(curKey)) {\n        existingImmediateParentDeps.push(curKey);\n        dependencyMap.addDependency(\n          immediateParent,\n          existingImmediateParentDeps,\n        );\n      }\n\n      curKey = immediateParent;\n    }\n  };\n}\n","import type { APP_MODE } from \"entities/App\";\n\nexport enum EComputationCacheName {\n  DEPENDENCY_MAP = \"DEPENDENCY_MAP\",\n  ALL_KEYS = \"ALL_KEYS\",\n}\n\nexport interface ICacheProps {\n  appId: string;\n  pageId: string;\n  appMode?: APP_MODE;\n  timestamp: string;\n  instanceId: string;\n}\n","import { APP_MODE } from \"entities/App\";\nimport localforage from \"localforage\";\nimport isNull from \"lodash/isNull\";\nimport loglevel from \"loglevel\";\nimport { EComputationCacheName, type ICacheProps } from \"./types\";\nimport debounce from \"lodash/debounce\";\n\ninterface ICachedData<T> {\n  value: T;\n}\n\ninterface ICacheLog {\n  lastAccessedAt: number;\n  createdAt: number | null;\n}\n\nexport class AppComputationCache {\n  // Singleton instance\n  private static instance: AppComputationCache | null = null;\n  private static CACHE_KEY_DELIMITER = \">\";\n\n  // The cache store for computation results\n  private readonly store: LocalForage;\n\n  // The cache store for cache event logs\n  private readonly cacheLogsStore: LocalForage;\n\n  // The app mode configuration for each cache type. This determines which app modes\n  // the cache should be enabled for\n  private readonly appModeConfig = {\n    [EComputationCacheName.DEPENDENCY_MAP]: [APP_MODE.PUBLISHED],\n    [EComputationCacheName.ALL_KEYS]: [APP_MODE.PUBLISHED],\n  };\n\n  constructor() {\n    this.store = localforage.createInstance({\n      name: \"AppComputationCache\",\n      storeName: \"cachedResults\",\n    });\n\n    this.cacheLogsStore = localforage.createInstance({\n      name: \"AppComputationCache\",\n      storeName: \"cacheMetadataStore\",\n    });\n  }\n\n  static getInstance(): AppComputationCache {\n    if (!AppComputationCache.instance) {\n      AppComputationCache.instance = new AppComputationCache();\n    }\n\n    return AppComputationCache.instance;\n  }\n\n  debouncedDeleteInvalidCacheEntries = debounce(\n    this.deleteInvalidCacheEntries,\n    5000,\n  );\n\n  /**\n   * Check if the computation result should be cached based on the app mode configuration\n   * @returns - A boolean indicating whether the cache should be enabled for the given app mode\n   */\n  isComputationCached({\n    cacheName,\n    cacheProps,\n  }: {\n    cacheName: EComputationCacheName;\n    cacheProps: ICacheProps;\n  }) {\n    const { appMode, timestamp } = cacheProps;\n\n    if (!appMode || !timestamp) {\n      return false;\n    }\n\n    return this.appModeConfig[cacheName].includes(appMode);\n  }\n\n  /**\n   * Checks if the value should be cached based on the app mode configuration and\n   * caches the computation result if it should be cached. It also tracks the cache usage\n   * @returns - A promise that resolves when the computation result is cached\n   */\n  async cacheComputationResult<T>({\n    cacheName,\n    cacheProps,\n    computationResult,\n  }: {\n    cacheProps: ICacheProps;\n    cacheName: EComputationCacheName;\n    computationResult: T;\n  }) {\n    const shouldCache = this.isComputationCached({\n      cacheName,\n      cacheProps,\n    });\n\n    if (!shouldCache) {\n      return;\n    }\n\n    const cacheKey = this.generateCacheKey({ cacheProps, cacheName });\n\n    try {\n      await this.store.setItem<ICachedData<T>>(cacheKey, {\n        value: computationResult,\n      });\n\n      await this.trackCacheUsage(cacheKey);\n    } catch (error) {\n      loglevel.debug(\"Error caching computation result:\", error);\n    }\n  }\n\n  /**\n   * Gets the cached computation result if it exists and is valid\n   * @returns - A promise that resolves with the cached computation result or null if it does not exist\n   */\n  async getCachedComputationResult<T>({\n    cacheName,\n    cacheProps,\n  }: {\n    cacheProps: ICacheProps;\n    cacheName: EComputationCacheName;\n  }): Promise<T | null> {\n    const shouldCache = this.isComputationCached({\n      cacheName,\n      cacheProps,\n    });\n\n    if (!shouldCache) {\n      return null;\n    }\n\n    const cacheKey = this.generateCacheKey({\n      cacheProps,\n      cacheName,\n    });\n\n    try {\n      const cached = await this.store.getItem<ICachedData<T>>(cacheKey);\n\n      if (isNull(cached)) {\n        // Cache miss\n        // Delete invalid cache entries when thread is idle\n        setTimeout(async () => {\n          await this.debouncedDeleteInvalidCacheEntries(cacheProps);\n        }, 0);\n\n        return null;\n      }\n\n      await this.trackCacheUsage(cacheKey);\n\n      return cached.value;\n    } catch (error) {\n      loglevel.error(\"Error getting cache result:\", error);\n\n      return null;\n    }\n  }\n\n  /**\n   * Generates a cache key from the index parts\n   * @returns - The generated cache key\n   */\n  generateCacheKey({\n    cacheName,\n    cacheProps,\n  }: {\n    cacheProps: ICacheProps;\n    cacheName: EComputationCacheName;\n  }) {\n    const { appId, appMode, instanceId, pageId, timestamp } = cacheProps;\n\n    const timeStampEpoch = new Date(timestamp).getTime();\n    const cacheKeyParts = [\n      instanceId,\n      appId,\n      pageId,\n      appMode,\n      timeStampEpoch,\n      cacheName,\n    ];\n\n    return cacheKeyParts.join(AppComputationCache.CACHE_KEY_DELIMITER);\n  }\n\n  /**\n   * Fetches the computation result from the cache or computes it if it does not exist\n   * @returns - A promise that resolves with the computation result\n   * @throws - Logs an error if the computation result cannot be fetched or computed and returns the computed fallback result\n   */\n  async fetchOrCompute<T>({\n    cacheName,\n    cacheProps,\n    computeFn,\n  }: {\n    cacheProps: ICacheProps;\n    computeFn: () => Promise<T> | T;\n    cacheName: EComputationCacheName;\n  }) {\n    const shouldCache = this.isComputationCached({\n      cacheName,\n      cacheProps,\n    });\n\n    if (!shouldCache) {\n      return computeFn();\n    }\n\n    try {\n      const cachedResult = await this.getCachedComputationResult<T>({\n        cacheProps,\n        cacheName,\n      });\n\n      if (cachedResult) {\n        return cachedResult;\n      }\n\n      const computationResult = await computeFn();\n\n      await this.cacheComputationResult({\n        cacheProps,\n        computationResult,\n        cacheName,\n      });\n\n      return computationResult;\n    } catch (error) {\n      loglevel.error(\"Error getting cache result:\", error);\n      const fallbackResult = await computeFn();\n\n      return fallbackResult;\n    }\n  }\n\n  /**\n   * Tracks the cache usage by updating the last accessed timestamp of the cache\n   * @param name - The name of the cache\n   * @returns - A promise that resolves when the cache usage is tracked\n   * @throws - Logs an error if the cache usage cannot be tracked\n   */\n  async trackCacheUsage(name: string) {\n    try {\n      const currentLog = await this.cacheLogsStore.getItem<ICacheLog>(name);\n\n      await this.cacheLogsStore.setItem(name, {\n        lastAccessedAt: Date.now(),\n        createdAt: currentLog?.createdAt || Date.now(),\n      });\n    } catch (error) {\n      loglevel.error(\"Error tracking cache usage:\", error);\n    }\n  }\n\n  /**\n   * Delete invalid cache entries\n   * @returns - A promise that resolves when the invalid cache entries are deleted\n   */\n\n  async deleteInvalidCacheEntries(cacheProps: ICacheProps) {\n    try {\n      // Get previous entry keys\n      const cacheKeys = await this.store.keys();\n\n      // Get invalid cache keys\n      const invalidCacheKeys = cacheKeys.filter((key) => {\n        const keyParts = key.split(AppComputationCache.CACHE_KEY_DELIMITER);\n        const cacheKeyTimestamp = parseInt(keyParts[4], 10);\n\n        return (\n          keyParts[0] === cacheProps.instanceId &&\n          keyParts[1] === cacheProps.appId &&\n          keyParts[3] === cacheProps.appMode &&\n          cacheKeyTimestamp !== new Date(cacheProps.timestamp).getTime()\n        );\n      });\n\n      // Delete invalid cache entries\n      await Promise.all(\n        invalidCacheKeys.map(async (key) => this.store.removeItem(key)),\n      );\n\n      // Delete invalid cache logs\n      await Promise.all(\n        invalidCacheKeys.map(async (key) =>\n          this.cacheLogsStore.removeItem(key),\n        ),\n      );\n    } catch (error) {\n      loglevel.error(\"Error deleting invalid cache entries:\", error);\n    }\n  }\n\n  static resetInstance() {\n    AppComputationCache.instance = null;\n  }\n}\n\nexport const appComputationCache = AppComputationCache.getInstance();\n\nexport default appComputationCache;\n","import type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  getAllPaths,\n  DataTreeDiffEvent,\n  getEntityNameAndPropertyPath,\n  isDynamicLeaf,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type {\n  WidgetEntity,\n  ActionEntity,\n  JSActionEntity,\n  DataTreeEntityObject,\n} from \"ee/entities/DataTree/types\";\nimport type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { getEntityId, getEvalErrorPath } from \"utils/DynamicBindingUtils\";\nimport { convertArrayToObject, extractInfoFromBindings } from \"./utils\";\nimport type DataTreeEvaluator from \"workers/common/DataTreeEvaluator\";\nimport { get, isEmpty, set } from \"lodash\";\nimport { getFixedTimeDifference } from \"../DataTreeEvaluator/utils\";\nimport {\n  getEntityDependencies,\n  getEntityPathDependencies,\n} from \"./utils/getEntityDependencies\";\nimport { DependencyMapUtils } from \"entities/DependencyMap/DependencyMapUtils\";\nimport { AppsmithFunctionsWithFields } from \"components/editorComponents/ActionCreator/constants\";\nimport {\n  getAllSetterFunctions,\n  getEntitySetterFunctions,\n} from \"ee/workers/Evaluation/Actions\";\nimport { isWidgetActionOrJsObject } from \"ee/entities/DataTree/utils\";\nimport { getValidEntityType } from \"workers/common/DataTreeEvaluator/utils\";\nimport appComputationCache from \"../AppComputationCache\";\nimport {\n  EComputationCacheName,\n  type ICacheProps,\n} from \"../AppComputationCache/types\";\nimport type DependencyMap from \"entities/DependencyMap\";\nimport { profileFn } from \"instrumentation/generateWebWorkerTraces\";\nimport type { WebworkerSpanData, Attributes } from \"instrumentation/types\";\n\nexport async function createDependencyMap(\n  dataTreeEvalRef: DataTreeEvaluator,\n  unEvalTree: DataTree,\n  configTree: ConfigTree,\n  cacheProps: ICacheProps,\n  webworkerSpans: Record<string, WebworkerSpanData | Attributes> = {},\n) {\n  const { allKeys, dependencyMap } = dataTreeEvalRef;\n\n  const allAppsmithInternalFunctions = convertArrayToObject(\n    AppsmithFunctionsWithFields,\n  );\n  const setterFunctions = getAllSetterFunctions(unEvalTree, configTree);\n\n  profileFn(\"createDependencyMap.addNodes\", {}, webworkerSpans, async () => {\n    dependencyMap.addNodes(\n      { ...allKeys, ...allAppsmithInternalFunctions, ...setterFunctions },\n      false,\n    );\n  });\n\n  const dependencyMapCache =\n    await appComputationCache.getCachedComputationResult<\n      Record<string, string[]>\n    >({\n      cacheProps,\n      cacheName: EComputationCacheName.DEPENDENCY_MAP,\n    });\n\n  if (dependencyMapCache) {\n    profileFn(\"createDependencyMap.addDependency\", {}, webworkerSpans, () => {\n      Object.entries(dependencyMapCache).forEach(([path, references]) => {\n        dependencyMap.addDependency(path, references);\n      });\n    });\n  } else {\n    let shouldCache = true;\n\n    Object.keys(configTree).forEach((entityName) => {\n      const entity = unEvalTree[entityName];\n      const entityConfig = configTree[entityName];\n      const entityDependencies = getEntityDependencies(\n        entity as DataTreeEntityObject,\n        entityConfig,\n        allKeys,\n      );\n\n      for (const path of Object.keys(entityDependencies)) {\n        const pathDependencies = entityDependencies[path];\n        const { errors, references } = extractInfoFromBindings(\n          pathDependencies,\n          allKeys,\n        );\n\n        dependencyMap.addDependency(path, references);\n        dataTreeEvalRef.errors.push(...errors);\n\n        if (errors.length) {\n          shouldCache = false;\n        }\n      }\n    });\n\n    DependencyMapUtils.makeParentsDependOnChildren(dependencyMap);\n\n    if (shouldCache) {\n      await appComputationCache.cacheComputationResult({\n        cacheProps,\n        cacheName: EComputationCacheName.DEPENDENCY_MAP,\n        computationResult: dependencyMap.dependencies,\n      });\n    }\n  }\n\n  return {\n    dependencies: dependencyMap.dependencies,\n    inverseDependencies: dependencyMap.inverseDependencies,\n  };\n}\nconst addingAffectedNodesToList = (\n  affectedNodes: Set<string>,\n  addedNodes: string[],\n) => {\n  addedNodes.forEach((v) => affectedNodes.add(v));\n};\n\nconst addNodesToDependencyMap =\n  (affectedNodes: Set<string>, dependencyMap: DependencyMap) =>\n  (addedNodes: Record<string, true>, strict?: boolean) => {\n    const didUpdateDep = dependencyMap.addNodes(addedNodes, strict);\n\n    if (didUpdateDep) {\n      addingAffectedNodesToList(affectedNodes, Object.keys(addedNodes));\n    }\n\n    return didUpdateDep;\n  };\n\nconst setDependenciesToDependencyMap =\n  (affectedNodes: Set<string>, dependencyMap: DependencyMap) =>\n  (node: string, dependencies: string[]) => {\n    dependencyMap.addDependency(node, dependencies);\n\n    addingAffectedNodesToList(affectedNodes, [node, ...dependencies]);\n  };\n\nexport const updateDependencyMap = ({\n  configTree,\n  dataTreeEvalRef,\n  translatedDiffs,\n  unEvalDataTree,\n}: {\n  dataTreeEvalRef: DataTreeEvaluator;\n  translatedDiffs: Array<DataTreeDiff>;\n  unEvalDataTree: DataTree;\n  configTree: ConfigTree;\n}) => {\n  const diffCalcStart = performance.now();\n  const dependenciesOfRemovedPaths: Array<string> = [];\n  const removedPaths: Array<{ entityId: string; fullpath: string }> = [];\n  let didUpdateDependencyMap = false;\n  const { allKeys, dependencyMap, oldConfigTree, oldUnEvalTree } =\n    dataTreeEvalRef;\n  let { errors: dataTreeEvalErrors } = dataTreeEvalRef;\n  const affectedNodes: Set<string> = new Set();\n  const addNodesToDepedencyMapFn = addNodesToDependencyMap(\n    affectedNodes,\n    dependencyMap,\n  );\n  const setDependenciesToDepedencyMapFn = setDependenciesToDependencyMap(\n    affectedNodes,\n    dependencyMap,\n  );\n\n  translatedDiffs.forEach((dataTreeDiff) => {\n    const {\n      event,\n      payload: { propertyPath: fullPropertyPath, value },\n    } = dataTreeDiff;\n    const { entityName } = getEntityNameAndPropertyPath(fullPropertyPath);\n    const entityConfig =\n      event === DataTreeDiffEvent.DELETE\n        ? oldConfigTree[entityName]\n        : configTree[entityName];\n\n    const entity =\n      event === DataTreeDiffEvent.DELETE\n        ? oldUnEvalTree[entityName]\n        : unEvalDataTree[entityName];\n    const entityType = getValidEntityType(entity, entityConfig);\n\n    if (entityType !== \"noop\") {\n      switch (event) {\n        case DataTreeDiffEvent.NEW: {\n          const allAddedPaths = getAllPaths({\n            [fullPropertyPath]: get(unEvalDataTree, fullPropertyPath),\n          });\n\n          // If a new entity is added, add setter functions to all nodes\n          if (entityName === fullPropertyPath) {\n            const addedNodes = getEntitySetterFunctions(\n              entityConfig,\n              entityName,\n              entity,\n            );\n\n            didUpdateDependencyMap =\n              addNodesToDepedencyMapFn(addedNodes) || didUpdateDependencyMap;\n          }\n\n          didUpdateDependencyMap =\n            addNodesToDepedencyMapFn(allAddedPaths, false) ||\n            didUpdateDependencyMap;\n\n          if (isWidgetActionOrJsObject(entity)) {\n            if (!isDynamicLeaf(unEvalDataTree, fullPropertyPath, configTree)) {\n              const entityDependencyMap = getEntityDependencies(\n                entity,\n                configTree[entityName],\n                allKeys,\n              );\n\n              if (!isEmpty(entityDependencyMap)) {\n                // The entity might already have some dependencies,\n                // so we just want to update those\n                Object.entries(entityDependencyMap).forEach(\n                  ([path, pathDependencies]) => {\n                    const { errors: extractDependencyErrors, references } =\n                      extractInfoFromBindings(pathDependencies, allKeys);\n\n                    setDependenciesToDepedencyMapFn(path, references);\n\n                    didUpdateDependencyMap = true;\n                    dataTreeEvalErrors = dataTreeEvalErrors.concat(\n                      extractDependencyErrors,\n                    );\n                  },\n                );\n              }\n            } else {\n              const entityPathDependencies = getEntityPathDependencies(\n                entity,\n                entityConfig,\n                fullPropertyPath,\n                allKeys,\n              );\n              const { errors: extractDependencyErrors, references } =\n                extractInfoFromBindings(entityPathDependencies, allKeys);\n\n              setDependenciesToDepedencyMapFn(fullPropertyPath, references);\n\n              didUpdateDependencyMap = true;\n              dataTreeEvalErrors = dataTreeEvalErrors.concat(\n                extractDependencyErrors,\n              );\n            }\n          }\n\n          break;\n        }\n        case DataTreeDiffEvent.DELETE: {\n          const allDeletedPaths = getAllPaths({\n            [fullPropertyPath]: get(oldUnEvalTree, fullPropertyPath),\n          });\n\n          // If an entity is deleted, remove all setter functions\n          if (entityName === fullPropertyPath) {\n            const didUpdateDep = dependencyMap.removeNodes(\n              getEntitySetterFunctions(entityConfig, entityName, entity),\n            );\n\n            if (didUpdateDep) didUpdateDependencyMap = true;\n          }\n\n          for (const deletedPath of Object.keys(allDeletedPaths)) {\n            const pathsThatDependOnDeletedPath =\n              dependencyMap.getDependents(deletedPath);\n\n            dependenciesOfRemovedPaths.push(...pathsThatDependOnDeletedPath);\n          }\n\n          const didUpdateDeps = dependencyMap.removeNodes(allDeletedPaths);\n\n          if (didUpdateDeps) didUpdateDependencyMap = true;\n\n          if (isWidgetActionOrJsObject(entity)) {\n            const entityId = getEntityId(entity);\n\n            for (const deletedPath of Object.keys(allDeletedPaths)) {\n              removedPaths.push({\n                entityId: entityId || \"\",\n                fullpath: deletedPath,\n              });\n            }\n          }\n\n          break;\n        }\n        case DataTreeDiffEvent.EDIT: {\n          if (isWidgetActionOrJsObject(entity) && typeof value === \"string\") {\n            const entity: ActionEntity | WidgetEntity | JSActionEntity =\n              unEvalDataTree[entityName] as\n                | ActionEntity\n                | WidgetEntity\n                | JSActionEntity;\n            const entityConfig = configTree[entityName];\n            const fullPropertyPath = dataTreeDiff.payload.propertyPath;\n\n            const entityPathDependencies = getEntityPathDependencies(\n              entity,\n              entityConfig,\n              fullPropertyPath,\n              allKeys,\n            );\n            const { errors: extractDependencyErrors, references } =\n              extractInfoFromBindings(entityPathDependencies, allKeys);\n\n            setDependenciesToDepedencyMapFn(fullPropertyPath, references);\n\n            didUpdateDependencyMap = true;\n            dataTreeEvalErrors = dataTreeEvalErrors.concat(\n              extractDependencyErrors,\n            );\n          }\n\n          break;\n        }\n        default: {\n          break;\n        }\n      }\n    }\n  });\n\n  const diffCalcEnd = performance.now();\n  const updateChangedDependenciesStart = performance.now();\n\n  if (didUpdateDependencyMap) {\n    DependencyMapUtils.linkAffectedChildNodesToParent(\n      dependencyMap,\n      affectedNodes,\n    );\n    dataTreeEvalRef.sortedDependencies = dataTreeEvalRef.sortDependencies(\n      dependencyMap,\n      translatedDiffs,\n    );\n  }\n\n  /** We need this in order clear out the paths that could have errors when a property is deleted */\n  if (removedPaths.length) {\n    removedPaths.forEach(({ fullpath }) => {\n      set(dataTreeEvalRef.evalProps, getEvalErrorPath(fullpath), []);\n    });\n  }\n\n  const updateChangedDependenciesStop = performance.now();\n\n  dataTreeEvalRef.logs.push({\n    diffCalcDeps: (diffCalcEnd - diffCalcStart).toFixed(2),\n    updateChangedDependencies: getFixedTimeDifference(\n      updateChangedDependenciesStop,\n      updateChangedDependenciesStart,\n    ),\n  });\n\n  return {\n    dependenciesOfRemovedPaths,\n    removedPaths,\n    dependencies: dependencyMap.dependencies,\n    inverseDependencies: dependencyMap.inverseDependencies,\n  };\n};\n","import type { DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport type { TDataStore } from \".\";\nimport { isAction, isJSAction } from \"ee/workers/Evaluation/evaluationUtils\";\nimport { get, isEmpty, set } from \"lodash\";\n\nexport function updateTreeWithData(tree: DataTree, dataStore: TDataStore) {\n  if (isEmpty(dataStore)) return;\n\n  for (const entityName of Object.keys(tree)) {\n    const entity = tree[entityName];\n\n    if (!dataStore.hasOwnProperty(entityName)) continue;\n\n    if (isAction(entity)) {\n      set(entity, \"data\", get(dataStore, `${entityName}.data`));\n    }\n\n    if (isJSAction(entity)) {\n      const allFunctionsInStore = Object.keys(dataStore[entityName]);\n\n      allFunctionsInStore.forEach((functionName) => {\n        set(\n          entity[functionName],\n          `data`,\n          get(dataStore, `${entityName}.${functionName}.data`),\n        );\n      });\n    }\n  }\n}\n","import type {\n  DataTreeEvaluationProps,\n  EvalError as TEvalError,\n  EvaluationError,\n} from \"utils/DynamicBindingUtils\";\nimport {\n  EvalErrorTypes,\n  getDynamicBindings,\n  getEntityDynamicBindingPathList,\n  getEntityId,\n  getEntityName,\n  getEvalErrorPath,\n  getEvalValuePath,\n  isChildPropertyPath,\n  isDynamicValue,\n  isPathDynamicTrigger,\n  PropertyEvaluationErrorType,\n} from \"utils/DynamicBindingUtils\";\nimport type { WidgetTypeConfigMap } from \"WidgetProvider/factory\";\nimport type {\n  WidgetEntity,\n  WidgetEntityConfig,\n  ActionEntity,\n  JSActionEntityConfig,\n  PrivateWidgets,\n  ActionEntityConfig,\n  DataTreeEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport type {\n  DataTree,\n  DataTreeEntity,\n  ConfigTree,\n  UnEvalTree,\n} from \"entities/DataTree/dataTreeTypes\";\nimport {\n  EvaluationSubstitutionType,\n  ENTITY_TYPE,\n} from \"ee/entities/DataTree/types\";\nimport type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  convertMicroDiffToDeepDiff,\n  getAllPathsBasedOnDiffPaths,\n  isPropertyAnEntityAction,\n} from \"ee/workers/Evaluation/evaluationUtils\";\n\nimport {\n  addDependantsOfNestedPropertyPaths,\n  addErrorToEntityProperty,\n  convertPathToString,\n  CrashingError,\n  getEntityNameAndPropertyPath,\n  getImmediateParentsOfPropertyPaths,\n  isAction,\n  isDynamicLeaf,\n  isJSAction,\n  isWidget,\n  translateDiffEventToDataTreeDiffEvent,\n  trimDependantChangePaths,\n  overrideWidgetProperties,\n  getAllPaths,\n  isNewEntity,\n  getStaleMetaStateIds,\n  convertJSFunctionsToString,\n  DataTreeDiffEvent,\n  resetValidationErrorsForEntityProperty,\n  isAPathDynamicBindingPath,\n  isAnyJSAction,\n  isNotEntity,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  difference,\n  flatten,\n  get,\n  isArray,\n  isEmpty,\n  isEqual,\n  isFunction,\n  isObject,\n  isUndefined,\n  set,\n  union,\n  unset,\n} from \"lodash\";\n\nimport type { Diff } from \"deep-diff\";\nimport { applyChange, diff } from \"deep-diff\";\nimport {\n  EXECUTION_PARAM_KEY,\n  EXECUTION_PARAM_REFERENCE_REGEX,\n  THIS_DOT_PARAMS_KEY,\n} from \"constants/AppsmithActionConstants/ActionConstants\";\nimport {\n  evaluateSync,\n  resetWorkerGlobalScope,\n  type EvalResult,\n  type EvaluateContext,\n  evaluateAsync,\n  setEvalContext,\n} from \"workers/Evaluation/evaluate\";\nimport { substituteDynamicBindingWithValues } from \"workers/Evaluation/evaluationSubstitution\";\nimport { Severity } from \"entities/AppsmithConsole\";\nimport { error as logError } from \"loglevel\";\nimport type { JSUpdate } from \"utils/JSPaneUtils\";\n\nimport type {\n  ActionValidationConfigMap,\n  ValidationConfig,\n} from \"constants/PropertyControlConstants\";\nimport { klona } from \"klona/full\";\nimport { klona as klonaJSON } from \"klona/json\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport {\n  updateDependencyMap,\n  createDependencyMap,\n} from \"workers/common/DependencyMap\";\nimport {\n  getJSEntities,\n  getUpdatedLocalUnEvalTreeAfterJSUpdates,\n  parseJSActions,\n  updateEvalTreeWithJSCollectionState,\n} from \"workers/Evaluation/JSObject\";\nimport {\n  getFixedTimeDifference,\n  getIsNewWidgetAdded,\n  getOnlyAffectedJSObjects,\n  replaceThisDotParams,\n} from \"./utils\";\nimport { isJSObjectFunction } from \"workers/Evaluation/JSObject/utils\";\nimport {\n  validateActionProperty,\n  validateAndParseWidgetProperty,\n  validateWidgetProperty,\n} from \"./validationUtils\";\nimport { errorModifier } from \"workers/Evaluation/errorModifier\";\nimport JSObjectCollection from \"workers/Evaluation/JSObject/Collection\";\nimport userLogs from \"workers/Evaluation/fns/overrides/console\";\nimport ExecutionMetaData from \"workers/Evaluation/fns/utils/ExecutionMetaData\";\nimport DependencyMap from \"entities/DependencyMap\";\nimport { DependencyMapUtils } from \"entities/DependencyMap/DependencyMapUtils\";\nimport { isWidgetActionOrJsObject } from \"ee/entities/DataTree/utils\";\nimport DataStore from \"workers/Evaluation/dataStore\";\nimport { updateTreeWithData } from \"workers/Evaluation/dataStore/utils\";\nimport microDiff from \"microdiff\";\nimport {\n  profileAsyncFn,\n  profileFn,\n} from \"instrumentation/generateWebWorkerTraces\";\nimport generateOverrideContext from \"ee/workers/Evaluation/generateOverrideContext\";\nimport appComputationCache from \"../AppComputationCache\";\nimport {\n  EComputationCacheName,\n  type ICacheProps,\n} from \"../AppComputationCache/types\";\nimport { getDataTreeContext } from \"ee/workers/Evaluation/Actions\";\nimport { WorkerEnv } from \"workers/Evaluation/handlers/workerEnv\";\nimport type { WebworkerSpanData, Attributes } from \"instrumentation/types\";\nimport type { AffectedJSObjects } from \"actions/EvaluationReduxActionTypes\";\nimport type { UpdateActionProps } from \"workers/Evaluation/handlers/types\";\n\ntype SortedDependencies = Array<string>;\nexport interface EvalProps {\n  [entityName: string]: DataTreeEvaluationProps;\n}\n\nexport default class DataTreeEvaluator {\n  dependencyMap: DependencyMap = new DependencyMap();\n  sortedDependencies: SortedDependencies = [];\n  dependencies: Record<string, string[]> = {};\n  inverseDependencies: Record<string, string[]> = {};\n  widgetConfigMap: WidgetTypeConfigMap = {};\n  evalTree: DataTree = {};\n  configTree: ConfigTree = {};\n\n  /**\n   * This contains raw evaluated value without any validation or parsing.\n   * This is used for revalidation as we do not store the raw validated value.\n   */\n  unParsedEvalTree: DataTree = {};\n  allKeys: Record<string, true> = {};\n  privateWidgets: PrivateWidgets = {};\n  oldUnEvalTree: UnEvalTree = {};\n  oldConfigTree: ConfigTree = {};\n  errors: TEvalError[] = [];\n  logs: unknown[] = [];\n  console = userLogs;\n  allActionValidationConfig?: {\n    [actionId: string]: ActionValidationConfigMap;\n  };\n\n  /**\n   * Sanitized eval values and errors\n   */\n  evalProps: EvalProps = {};\n  undefinedEvalValuesMap: Record<string, boolean> = {};\n\n  prevState = {};\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  setPrevState(state: any) {\n    this.prevState = state;\n  }\n  getPrevState() {\n    return this.prevState;\n  }\n  public hasCyclicalDependency = false;\n  constructor(\n    widgetConfigMap: WidgetTypeConfigMap,\n    allActionValidationConfig?: {\n      [actionId: string]: ActionValidationConfigMap;\n    },\n  ) {\n    this.allActionValidationConfig = allActionValidationConfig;\n    this.widgetConfigMap = widgetConfigMap;\n  }\n\n  getEvalTree() {\n    return this.evalTree;\n  }\n\n  getEvalProps() {\n    return this.evalProps;\n  }\n\n  setEvalTree(evalTree: DataTree) {\n    this.evalTree = evalTree;\n  }\n\n  getConfigTree() {\n    return this.configTree;\n  }\n\n  setConfigTree(configTree: ConfigTree) {\n    if (configTree) this.configTree = configTree;\n  }\n\n  getUnParsedEvalTree() {\n    return this.unParsedEvalTree;\n  }\n\n  setUnParsedEvalTree(unParsedEvalTree: DataTree) {\n    this.unParsedEvalTree = unParsedEvalTree;\n  }\n\n  getOldUnevalTree() {\n    return this.oldUnEvalTree;\n  }\n\n  /**\n   * Method to create all data required for linting and\n   * evaluation of the first tree\n   */\n  async setupFirstTree(\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    unEvalTree: any,\n    configTree: ConfigTree,\n    webworkerTelemetry: Record<string, WebworkerSpanData | Attributes> = {},\n    cacheProps: ICacheProps,\n  ) {\n    this.setConfigTree(configTree);\n\n    const totalFirstTreeSetupStartTime = performance.now();\n    // cloneDeep will make sure not to omit key which has value as undefined.\n    const firstCloneStartTime = performance.now();\n    let localUnEvalTree = klona(unEvalTree);\n    const firstCloneEndTime = performance.now();\n\n    let jsUpdates: Record<string, JSUpdate> = {};\n    //parse js collection to get functions\n    //save current state of js collection action and variables to be added to uneval tree\n    //save functions in resolveFunctions (as functions) to be executed as functions are not allowed in evalTree\n    //and functions are saved in dataTree as strings\n    const parseJSActionsStartTime = performance.now();\n    const parsedCollections = profileFn(\n      \"SetupFirstTree.parseJSActions\",\n      undefined,\n      webworkerTelemetry,\n      () => {\n        return parseJSActions(this, localUnEvalTree);\n      },\n    );\n    const parseJSActionsEndTime = performance.now();\n\n    jsUpdates = parsedCollections.jsUpdates;\n    localUnEvalTree = getUpdatedLocalUnEvalTreeAfterJSUpdates(\n      jsUpdates,\n      localUnEvalTree,\n      configTree,\n    );\n    const localUnEvalTreeJSCollection = getJSEntities(localUnEvalTree);\n    const stringifiedLocalUnEvalTreeJSCollection = convertJSFunctionsToString(\n      localUnEvalTreeJSCollection,\n      configTree,\n    );\n    const unEvalTreeWithStrigifiedJSFunctions = Object.assign(\n      {},\n      localUnEvalTree,\n      stringifiedLocalUnEvalTreeJSCollection,\n    );\n    const allKeysGenerationStartTime = performance.now();\n\n    this.allKeys = await appComputationCache.fetchOrCompute({\n      cacheProps,\n      cacheName: EComputationCacheName.ALL_KEYS,\n      computeFn: () => getAllPaths(unEvalTreeWithStrigifiedJSFunctions),\n    });\n\n    const allKeysGenerationEndTime = performance.now();\n\n    const createDependencyMapStartTime = performance.now();\n\n    const { dependencies, inverseDependencies } = await profileAsyncFn(\n      \"createDependencyMap\",\n      async () =>\n        createDependencyMap(\n          this,\n          localUnEvalTree,\n          configTree,\n          cacheProps,\n          webworkerTelemetry,\n        ),\n      webworkerTelemetry,\n    );\n\n    const createDependencyMapEndTime = performance.now();\n\n    this.dependencies = dependencies;\n    this.inverseDependencies = inverseDependencies;\n\n    const sortDependenciesStartTime = performance.now();\n\n    this.sortedDependencies = this.sortDependencies(this.dependencyMap);\n    const sortDependenciesEndTime = performance.now();\n\n    const secondCloneStartTime = performance.now();\n\n    this.oldUnEvalTree = klona(localUnEvalTree);\n    this.oldConfigTree = configTree;\n    const secondCloneEndTime = performance.now();\n\n    const totalFirstTreeSetupEndTime = performance.now();\n\n    const timeTakenForSetupFirstTree = {\n      total: getFixedTimeDifference(\n        totalFirstTreeSetupEndTime,\n        totalFirstTreeSetupStartTime,\n      ),\n      clone: getFixedTimeDifference(\n        firstCloneEndTime + secondCloneEndTime,\n        firstCloneStartTime + secondCloneStartTime,\n      ),\n      allKeys: getFixedTimeDifference(\n        allKeysGenerationEndTime,\n        allKeysGenerationStartTime,\n      ),\n      createDependencyMap: getFixedTimeDifference(\n        createDependencyMapEndTime,\n        createDependencyMapStartTime,\n      ),\n      sortDependencies: getFixedTimeDifference(\n        sortDependenciesEndTime,\n        sortDependenciesStartTime,\n      ),\n      parseJSActions: getFixedTimeDifference(\n        parseJSActionsEndTime,\n        parseJSActionsStartTime,\n      ),\n    };\n\n    this.logs.push({\n      timeTakenForSetupFirstTree,\n      dependencies: this.dependencies,\n      inverseDependencies: this.inverseDependencies,\n    });\n\n    return {\n      jsUpdates,\n      evalOrder: this.sortedDependencies,\n    };\n  }\n\n  /**\n   * Mutates the dataTree.\n   * Validates all the nodes of the tree to make sure all the values are as expected according to the validation config\n   *\n   * For example :- If Button.isDisabled is set to false in propertyPane then it would be passed as \"false\" in unEvalTree and validateTree method makes sure to convert it to boolean.\n   * @param tree\n   * @param option\n   * @param configTree\n   * @returns\n   */\n  validatedTree(\n    dataTree: DataTree,\n    option: {\n      evalProps: EvalProps;\n    },\n    configTree: ConfigTree,\n  ) {\n    const unParsedEvalTree = this.getUnParsedEvalTree();\n    const { evalProps } = option;\n\n    for (const [entityName, entity] of Object.entries(dataTree)) {\n      if (!isWidget(entity)) continue;\n\n      const entityConfig = configTree[entityName] as WidgetEntityConfig;\n      const validationPathsMap = Object.entries(entityConfig.validationPaths);\n\n      for (const [propertyPath, validationConfig] of validationPathsMap) {\n        const fullPropertyPath = `${entityName}.${propertyPath}`;\n\n        const value = get(\n          unParsedEvalTree,\n          fullPropertyPath,\n          get(entity, propertyPath),\n        );\n        // Pass it through parse\n        const { isValid, messages, parsed } = validateWidgetProperty(\n          validationConfig,\n          value,\n          entity,\n          propertyPath,\n        );\n\n        set(entity, propertyPath, parsed);\n\n        resetValidationErrorsForEntityProperty({\n          evalProps,\n          fullPropertyPath,\n        });\n\n        if (!isValid) {\n          const evalErrors: EvaluationError[] =\n            messages?.map((message) => ({\n              errorType: PropertyEvaluationErrorType.VALIDATION,\n              errorMessage: message ?? {},\n              severity: Severity.ERROR,\n              raw: value,\n            })) ?? [];\n\n          addErrorToEntityProperty({\n            errors: evalErrors,\n            evalProps,\n            fullPropertyPath,\n            configTree,\n          });\n        }\n      }\n    }\n  }\n\n  evalAndValidateFirstTree(): {\n    evalTree: DataTree;\n    evalMetaUpdates: EvalMetaUpdates;\n    staleMetaIds: string[];\n  } {\n    const evaluationStartTime = performance.now();\n\n    const evaluationOrder = this.sortedDependencies;\n\n    const unEvalTreeClone = klonaJSON(this.oldUnEvalTree);\n    // Evaluate\n    const { evalMetaUpdates, evaluatedTree, staleMetaIds } = this.evaluateTree(\n      unEvalTreeClone,\n      evaluationOrder,\n      undefined,\n      this.oldConfigTree,\n    );\n\n    /**\n     * We need to re-validate all widgets only in case of first tree\n     * Widget fields with custom validation functions can depend on other properties of the widget,\n     * which aren't evaluated/validated yet, thereby store incorrect validation errors in the previous step\n     */\n    this.validatedTree(\n      evaluatedTree,\n      {\n        evalProps: this.evalProps,\n      },\n      this.oldConfigTree,\n    );\n\n    const evaluationEndTime = performance.now();\n\n    this.setEvalTree(evaluatedTree);\n\n    const timeTakenForEvalAndValidateFirstTree = {\n      evaluation: getFixedTimeDifference(\n        evaluationEndTime,\n        evaluationStartTime,\n      ),\n    };\n\n    this.logs.push({ timeTakenForEvalAndValidateFirstTree });\n\n    return {\n      evalTree: this.getEvalTree(),\n      evalMetaUpdates,\n      staleMetaIds,\n    };\n  }\n\n  /**\n   *  TODO: This is a temporary fix to update unevalTree with JSObjectCollection state.\n   * In ideal scenario, the unevalTree should be updated with JSObjectCollection state in the dataTreeFactory itself. We will need to try to send\n   * {\n   * \"JsObject1\": {\n   *    function1: \"function() { return 1; }\",\n   *    \"function1.data\": {},\n   *    function2: \"function() { return 2; }\",\n   *    \"function2.data\": {},\n   *  }\n   * }\n   *  */\n  updateUnEvalTreeJSFunction(unevalTree: DataTree, configTree: ConfigTree) {\n    //add functions and variables to unevalTree\n    const unEvalJSCollection = JSObjectCollection.getUnEvalState();\n\n    Object.keys(unEvalJSCollection).forEach((entityName) => {\n      const entity = unevalTree[entityName];\n\n      if (!isJSAction(entity)) return;\n\n      const updates = unEvalJSCollection[entityName];\n\n      if (unevalTree[entityName]) {\n        Object.keys(updates).forEach((key) => {\n          const data = get(unevalTree, `${entityName}.${key}.data`, undefined);\n\n          if (isJSObjectFunction(unevalTree, entityName, key, configTree)) {\n            set(unevalTree, `${entityName}.${key}`, new String(updates[key]));\n            set(unevalTree, `${entityName}.${key}.data`, data);\n          } else {\n            set(unevalTree, `${entityName}.${key}`, updates[key]);\n          }\n        });\n      }\n    });\n\n    return unevalTree;\n  }\n\n  /**\n   *\n   * In this method, we find the updatedJSobjects then parse the updated jsObject body and update the resolved functions and variable accordingly.\n   * getUpdatedLocalUnEvalTreeAfterJSUpdates- We update the unevalTree with the updated jsObject properties.\n   */\n  generateJSObjectUpdates({\n    affectedJSObjects = { isAllAffected: false, ids: [] },\n    configTree,\n    unEvalTree,\n    webworkerTelemetry,\n  }: {\n    unEvalTree: UnEvalTree;\n    configTree: ConfigTree;\n    webworkerTelemetry: Record<string, WebworkerSpanData | Attributes>;\n    affectedJSObjects: AffectedJSObjects;\n  }) {\n    //get difference in js collection body to be parsed\n    const oldUnEvalTreeJSCollections = getJSEntities(this.oldUnEvalTree);\n    const localUnEvalTreeJSCollection = getJSEntities(unEvalTree);\n    const jsDifferences = profileFn(\n      \"SetupUpdateTree.Diff1\",\n      undefined,\n      webworkerTelemetry,\n      () =>\n        convertMicroDiffToDeepDiff(\n          microDiff(\n            getOnlyAffectedJSObjects(\n              oldUnEvalTreeJSCollections,\n              affectedJSObjects,\n            ),\n            getOnlyAffectedJSObjects(\n              localUnEvalTreeJSCollection,\n              affectedJSObjects,\n            ),\n          ) || [],\n        ),\n    );\n\n    const jsTranslatedDiffs = flatten(\n      jsDifferences.map((diff) =>\n        translateDiffEventToDataTreeDiffEvent(diff, unEvalTree),\n      ),\n    );\n\n    //save parsed functions in resolveJSFunctions, update current state of js collection\n    const { jsUpdates } = profileFn(\n      \"SetupUpdateTree.parseJSActions\",\n      undefined,\n      webworkerTelemetry,\n      () =>\n        parseJSActions(this, unEvalTree, this.oldUnEvalTree, jsTranslatedDiffs),\n    );\n\n    //update local data tree if js body has updated (remove/update/add js functions or variables)\n    const updatedUnEvalTree = getUpdatedLocalUnEvalTreeAfterJSUpdates(\n      jsUpdates,\n      unEvalTree,\n      configTree,\n    );\n\n    const stringifiedOldUnEvalTreeJSCollections = convertJSFunctionsToString(\n      oldUnEvalTreeJSCollections,\n      this.oldConfigTree,\n    );\n    const stringifiedLocalUnEvalTreeJSCollection = convertJSFunctionsToString(\n      localUnEvalTreeJSCollection,\n      configTree,\n    );\n\n    const oldUnEvalTreeWithStringifiedJSFunctions = Object.assign(\n      {},\n      this.oldUnEvalTree,\n      stringifiedOldUnEvalTreeJSCollections,\n    );\n\n    const unEvalTreeWithStringifiedJSFunctions = Object.assign(\n      {},\n      updatedUnEvalTree,\n      stringifiedLocalUnEvalTreeJSCollection,\n    );\n\n    return {\n      oldUnEvalTreeWithStringifiedJSFunctions,\n      unEvalTreeWithStringifiedJSFunctions,\n      jsUpdates,\n      updatedUnEvalTree,\n    };\n  }\n\n  /**\n   * Method to create all data required for linting and\n   * evaluation of the updated tree\n   */\n\n  setupUpdateTree(\n    unEvalTree: UnEvalTree,\n    configTree: ConfigTree,\n    webworkerTelemetry: Record<string, WebworkerSpanData | Attributes> = {},\n    affectedJSObjects: AffectedJSObjects = { isAllAffected: false, ids: [] },\n    actionDataPayloadConsolidated?: UpdateActionProps[],\n  ): {\n    unEvalUpdates: DataTreeDiff[];\n    evalOrder: string[];\n    jsUpdates: Record<string, JSUpdate>;\n    removedPaths: Array<{ entityId: string; fullpath: string }>;\n    isNewWidgetAdded: boolean;\n  } {\n    this.setConfigTree(configTree);\n\n    const localUnEvalTree = Object.assign({}, unEvalTree);\n    const updatedUnEvalTreeJSFunction = this.updateUnEvalTreeJSFunction(\n      localUnEvalTree,\n      configTree,\n    );\n\n    const {\n      jsUpdates,\n      oldUnEvalTreeWithStringifiedJSFunctions,\n      unEvalTreeWithStringifiedJSFunctions,\n      updatedUnEvalTree: updatedUnEvalTreeJSObjects,\n    } = this.generateJSObjectUpdates({\n      unEvalTree: updatedUnEvalTreeJSFunction,\n      configTree,\n      webworkerTelemetry,\n      affectedJSObjects,\n    });\n\n    const differences = profileFn(\n      \"unEvalTreeWithStringifiedJSFunctionsDiff\",\n      undefined,\n      webworkerTelemetry,\n      () =>\n        diff(\n          oldUnEvalTreeWithStringifiedJSFunctions,\n          unEvalTreeWithStringifiedJSFunctions,\n        ) || [],\n    );\n\n    // Since eval tree is listening to possible events that don't cause differences\n    // We want to check if no diffs are present and bail out early\n    if (differences.length === 0 && !actionDataPayloadConsolidated?.length) {\n      return {\n        removedPaths: [],\n        unEvalUpdates: [],\n        evalOrder: [],\n        jsUpdates: {},\n        isNewWidgetAdded: false,\n      };\n    }\n\n    DataStore.update(differences);\n\n    //find all differences which can lead to updating of dependency map\n    const translatedDiffs = flatten(\n      differences.map((diff) =>\n        translateDiffEventToDataTreeDiffEvent(diff, updatedUnEvalTreeJSObjects),\n      ),\n    );\n\n    // TODO => Optimize using dataTree diff\n\n    this.allKeys = profileFn(\"getAllPaths\", undefined, webworkerTelemetry, () =>\n      getAllPathsBasedOnDiffPaths(\n        unEvalTreeWithStringifiedJSFunctions,\n        translatedDiffs,\n        this.allKeys,\n      ),\n    );\n    // Find all the paths that have changed as part of the difference and update the\n    // global dependency map if an existing dynamic binding has now become legal\n    const {\n      dependencies,\n      dependenciesOfRemovedPaths,\n      inverseDependencies,\n      removedPaths,\n    } = profileFn(\"updateDependencyMap\", undefined, webworkerTelemetry, () => {\n      return updateDependencyMap({\n        configTree,\n        dataTreeEvalRef: this,\n        translatedDiffs,\n        unEvalDataTree: updatedUnEvalTreeJSObjects,\n      });\n    });\n\n    this.dependencies = dependencies;\n    this.inverseDependencies = inverseDependencies;\n\n    const pathsChangedSet = new Set<string[]>(\n      actionDataPayloadConsolidated?.map(({ dataPath, entityName }) => [\n        entityName,\n        dataPath,\n      ]) || [],\n    );\n\n    for (const diff of differences) {\n      if (isArray(diff.path)) {\n        pathsChangedSet.add(diff.path);\n      }\n    }\n\n    const updatedValuePaths = [...pathsChangedSet];\n\n    this.updateEvalTreeWithChanges({ differences });\n    const setupUpdateTreeOutput = profileFn(\n      \"setupTree\",\n      undefined,\n      webworkerTelemetry,\n      () => {\n        const pathsToSkipFromEval =\n          actionDataPayloadConsolidated\n            ?.map(({ dataPath, entityName }) => {\n              return [entityName, dataPath];\n            })\n            .map((path: string[]) => path.join(\".\")) || [];\n\n        return this.setupTree(updatedUnEvalTreeJSObjects, updatedValuePaths, {\n          dependenciesOfRemovedPaths,\n          removedPaths,\n          translatedDiffs,\n          pathsToSkipFromEval,\n        });\n      },\n    );\n\n    this.logs.push({\n      differences,\n      translatedDiffs,\n    });\n\n    return {\n      ...setupUpdateTreeOutput,\n      jsUpdates,\n    };\n  }\n\n  getEvaluationOrder({\n    pathsToSkipFromEval,\n    subTreeSortOrder,\n    unEvalTree,\n  }: {\n    unEvalTree: DataTree;\n    pathsToSkipFromEval: string[];\n    subTreeSortOrder: string[];\n  }) {\n    // Remove anything from the sort order that is not a dynamic leaf since only those need evaluation\n    const evaluationOrder: string[] = [];\n\n    for (const fullPath of subTreeSortOrder) {\n      if (pathsToSkipFromEval.includes(fullPath)) continue;\n\n      if (!isDynamicLeaf(unEvalTree, fullPath, this.getConfigTree())) continue;\n\n      const unEvalPropValue = get(unEvalTree, fullPath);\n      const evalPropValue = get(this.evalTree, fullPath);\n\n      evaluationOrder.push(fullPath);\n\n      if (isFunction(evalPropValue)) continue;\n\n      // Set all values from unEvalTree to the evalTree to run evaluation for unevaluated values.\n      set(this.evalTree, fullPath, unEvalPropValue);\n    }\n\n    return { evaluationOrder };\n  }\n\n  setupTree(\n    updatedUnEvalTree: UnEvalTree,\n    updatedValuePaths: string[][],\n    extraParams: {\n      dependenciesOfRemovedPaths?: string[];\n      removedPaths?: Array<{ entityId: string; fullpath: string }>;\n      translatedDiffs?: DataTreeDiff[];\n      pathsToSkipFromEval?: string[];\n    },\n  ) {\n    const {\n      dependenciesOfRemovedPaths = [],\n      pathsToSkipFromEval = [],\n      removedPaths = [],\n      translatedDiffs = [],\n    } = extraParams;\n\n    updateEvalTreeWithJSCollectionState(this.evalTree);\n\n    const calculateSortOrderStartTime = performance.now();\n    const subTreeSortOrder = this.calculateSubTreeSortOrder(\n      updatedValuePaths,\n      dependenciesOfRemovedPaths,\n      removedPaths,\n      updatedUnEvalTree,\n    );\n    const calculateSortOrderEndTime = performance.now();\n\n    const { evaluationOrder } = this.getEvaluationOrder({\n      unEvalTree: updatedUnEvalTree,\n      pathsToSkipFromEval,\n      subTreeSortOrder,\n    });\n\n    this.logs.push({\n      sortedDependencies: this.sortedDependencies,\n      inverseDependencies: this.inverseDependencies,\n      updatedDependencies: this.dependencies,\n      evaluationOrder: evaluationOrder,\n    });\n\n    // Remove any deleted paths from the eval tree\n    removedPaths.forEach((removedPath) => {\n      unset(this.evalTree, removedPath.fullpath);\n    });\n\n    const cloneStartTime = performance.now();\n\n    // TODO: For some reason we are passing some reference which are getting mutated.\n    // Need to check why big api responses are getting split between two eval runs\n    this.oldUnEvalTree = klona(updatedUnEvalTree);\n    this.oldConfigTree = Object.assign({}, this.getConfigTree());\n    const cloneEndTime = performance.now();\n\n    const timeTakenForSetupUpdateTree = {\n      calculateSubTreeSortOrder: getFixedTimeDifference(\n        calculateSortOrderEndTime,\n        calculateSortOrderStartTime,\n      ),\n      clone: getFixedTimeDifference(cloneEndTime, cloneStartTime),\n    };\n\n    this.logs.push({ timeTakenForSetupUpdateTree });\n\n    const isNewWidgetAdded = getIsNewWidgetAdded(\n      translatedDiffs,\n      updatedUnEvalTree,\n    );\n\n    return {\n      unEvalUpdates: translatedDiffs,\n      evalOrder: evaluationOrder,\n      removedPaths,\n      isNewWidgetAdded,\n    };\n  }\n\n  setupUpdateTreeWithDifferences(\n    updatedValuePaths: string[][],\n    pathsToSkipFromEval: string[] = [],\n  ): ReturnType<typeof DataTreeEvaluator.prototype.setupUpdateTree> {\n    const updatedUnEvalTree = Object.assign({}, this.oldUnEvalTree);\n\n    // skipped update local unEvalTree\n    if (updatedValuePaths.length === 0) {\n      return {\n        unEvalUpdates: [],\n        evalOrder: [],\n        jsUpdates: {},\n        removedPaths: [],\n        isNewWidgetAdded: false,\n      };\n    }\n\n    return {\n      ...this.setupTree(updatedUnEvalTree, updatedValuePaths, {\n        pathsToSkipFromEval,\n      }),\n      jsUpdates: {},\n    };\n  }\n\n  evalAndValidateSubTree(\n    evaluationOrder: string[],\n    configTree: ConfigTree,\n    unevalUpdates: DataTreeDiff[],\n    metaWidgetIds: string[] = [],\n  ): {\n    evalMetaUpdates: EvalMetaUpdates;\n    staleMetaIds: string[];\n    contextTree: DataTree;\n  } {\n    const evaluationStartTime = performance.now();\n\n    const {\n      contextTree,\n      evalMetaUpdates,\n      evaluatedTree: newEvalTree,\n      staleMetaIds,\n    } = this.evaluateTree(\n      this.evalTree,\n      evaluationOrder,\n      {\n        isFirstTree: false,\n        unevalUpdates,\n        metaWidgets: metaWidgetIds,\n      },\n      configTree,\n    );\n    const evaluationEndTime = performance.now();\n\n    this.setEvalTree(newEvalTree);\n\n    const timeTakenForEvalAndValidateSubTree = {\n      evaluation: getFixedTimeDifference(\n        evaluationEndTime,\n        evaluationStartTime,\n      ),\n    };\n\n    this.logs.push({ timeTakenForEvalAndValidateSubTree });\n\n    return {\n      evalMetaUpdates,\n      staleMetaIds,\n      contextTree,\n    };\n  }\n\n  getCompleteSortOrder(\n    changes: Array<string>,\n    inverseMap: Record<string, string[]>,\n  ): Array<string> {\n    let finalSortOrder: Array<string> = [];\n    let computeSortOrder = true;\n    // Initialize parents with the current sent of property paths that need to be evaluated\n    let parents = changes;\n    let subSortOrderArray: Array<string>;\n    let visitedNodes: string[] = [];\n\n    while (computeSortOrder) {\n      // Get all the nodes that would be impacted by the evaluation of the nodes in parents array in sorted order\n      subSortOrderArray = this.getEvaluationSortOrder(parents, inverseMap);\n      visitedNodes = union(visitedNodes, parents);\n      // Add all the sorted nodes in the final list\n      finalSortOrder = union(finalSortOrder, subSortOrderArray);\n\n      parents = getImmediateParentsOfPropertyPaths(subSortOrderArray);\n      // If we find parents of the property paths in the sorted array, we should continue finding all the nodes dependent\n      // on the parents\n      computeSortOrder = difference(parents, visitedNodes).length > 0;\n    }\n\n    // Remove duplicates from this list. Since we explicitly walk down the tree and implicitly (by fetching parents) walk\n    // up the tree, there are bound to be many duplicates.\n    const uniqueKeysInSortOrder = new Set(finalSortOrder);\n\n    // if a property path evaluation gets triggered by diff top order changes\n    // this could lead to incorrect sort order in spite of the bfs traversal\n    const sortOrderPropertyPaths: string[] = [];\n\n    this.sortedDependencies.forEach((path) => {\n      if (uniqueKeysInSortOrder.has(path)) {\n        sortOrderPropertyPaths.push(path);\n        // remove from the uniqueKeysInSortOrder\n        uniqueKeysInSortOrder.delete(path);\n      }\n    });\n    // Add any remaining paths in the uniqueKeysInSortOrder\n    const completeSortOrder = [\n      ...Array.from(uniqueKeysInSortOrder),\n      ...sortOrderPropertyPaths,\n    ];\n\n    //Trim this list to now remove the property paths which are simply entity names\n    const finalSortOrderArray: Array<string> = [];\n\n    completeSortOrder.forEach((propertyPath) => {\n      const lastIndexOfDot = propertyPath.lastIndexOf(\".\");\n\n      // Only do this for property paths and not the entity themselves\n      if (lastIndexOfDot !== -1) {\n        finalSortOrderArray.push(propertyPath);\n      }\n    });\n\n    return finalSortOrderArray;\n  }\n\n  getEvaluationSortOrder(\n    changes: Array<string>,\n    inverseMap: Record<string, string[]>,\n  ): Array<string> {\n    const sortOrder: Array<string> = [...changes];\n    let iterator = 0;\n\n    while (iterator < sortOrder.length) {\n      // Find all the nodes who are to be evaluated when sortOrder[iterator] changes\n      const newNodes = inverseMap[sortOrder[iterator]];\n\n      // If we find more nodes that would be impacted by the evaluation of the node being investigated\n      // we add these to the sort order.\n      if (newNodes) {\n        newNodes.forEach((toBeEvaluatedNode) => {\n          // Only add the nodes if they haven't been already added for evaluation in the list. Since we are doing\n          // breadth first traversal, we should be safe in not changing the evaluation order and adding this now at this\n          // point instead of the previous index found.\n          if (!sortOrder.includes(toBeEvaluatedNode)) {\n            sortOrder.push(toBeEvaluatedNode);\n          }\n        });\n      }\n\n      iterator++;\n    }\n\n    return sortOrder;\n  }\n\n  getPrivateWidgets(dataTree: DataTree): PrivateWidgets {\n    let privateWidgets: PrivateWidgets = {};\n\n    Object.keys(dataTree).forEach((entityName) => {\n      const entity = dataTree[entityName];\n\n      if (isWidget(entity) && !isEmpty(entity.privateWidgets)) {\n        privateWidgets = {\n          ...privateWidgets,\n          ...entity.privateWidgets,\n        };\n      }\n    });\n\n    return privateWidgets;\n  }\n\n  evaluateTree(\n    unEvalTree: DataTree,\n    evaluationOrder: Array<string>,\n    options: {\n      isFirstTree: boolean;\n      unevalUpdates: DataTreeDiff[];\n      metaWidgets: string[];\n    } = {\n      isFirstTree: true,\n      unevalUpdates: [],\n      metaWidgets: [],\n    },\n    oldConfigTree: ConfigTree,\n  ): {\n    evaluatedTree: DataTree;\n    evalMetaUpdates: EvalMetaUpdates;\n    staleMetaIds: string[];\n    contextTree: DataTree;\n  } {\n    resetWorkerGlobalScope();\n\n    const safeTree = klonaJSON(unEvalTree);\n    const dataStore = DataStore.getDataStore();\n    const dataStoreClone = klonaJSON(dataStore);\n\n    updateTreeWithData(safeTree, dataStoreClone);\n    updateTreeWithData(unEvalTree, dataStore);\n\n    /**\n     * contextTree is a mutable dataTree, it gets passed as a context for each evaluation\n     * and gets updated both, with evaluated values and mutations.\n     *\n     * SafeTree is free of mutations because we make sure to only set evaluated values into it.\n     */\n    const contextTree = unEvalTree;\n\n    errorModifier.updateAsyncFunctions(\n      contextTree,\n      this.getConfigTree(),\n      this.dependencyMap,\n    );\n\n    const evalMetaUpdates: EvalMetaUpdates = [];\n    const { isFirstTree, metaWidgets, unevalUpdates } = options;\n    let staleMetaIds: string[] = [];\n\n    const allNewEntityDiffSet = new Set(\n      unevalUpdates\n        .filter((v) => v.event === DataTreeDiffEvent.NEW)\n        .map((v) => v.payload.propertyPath),\n    );\n    let evalContextCache;\n\n    if (WorkerEnv.flags.release_evaluation_scope_cache) {\n      evalContextCache = getDataTreeContext({\n        dataTree: contextTree,\n        configTree: oldConfigTree,\n        isTriggerBased: false,\n      });\n    }\n\n    try {\n      for (const fullPropertyPath of evaluationOrder) {\n        const { entityName, propertyPath } =\n          getEntityNameAndPropertyPath(fullPropertyPath);\n        const entity = contextTree[entityName];\n        const entityConfig = oldConfigTree[entityName];\n\n        if (!isWidgetActionOrJsObject(entity)) continue;\n\n        // Skip evaluations for actions in JSObjects\n        if (isPropertyAnEntityAction(entity, propertyPath, entityConfig)) {\n          continue;\n        }\n\n        // TODO: Fix this the next time the file is edited\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        let unEvalPropertyValue = get(contextTree as any, fullPropertyPath);\n\n        const isADynamicBindingPath = isAPathDynamicBindingPath(\n          entity,\n          entityConfig,\n          propertyPath,\n        );\n\n        const isATriggerPath =\n          isWidget(entity) &&\n          isPathDynamicTrigger(\n            entityConfig as WidgetEntityConfig,\n            propertyPath,\n          );\n        let evalPropertyValue;\n        const requiresEval =\n          isADynamicBindingPath &&\n          !isATriggerPath &&\n          (isDynamicValue(unEvalPropertyValue) || isJSAction(entity));\n\n        if (propertyPath) {\n          set(this.evalProps, getEvalErrorPath(fullPropertyPath), []);\n        }\n\n        if (requiresEval) {\n          const evaluationSubstitutionType =\n            entityConfig.reactivePaths[propertyPath] ||\n            EvaluationSubstitutionType.TEMPLATE;\n\n          const contextData: EvaluateContext = {};\n\n          if (isAction(entity)) {\n            // Add empty object for this.params to avoid undefined errors\n            contextData.globalContext = {\n              [THIS_DOT_PARAMS_KEY]: {},\n            };\n\n            unEvalPropertyValue = replaceThisDotParams(unEvalPropertyValue);\n          }\n\n          try {\n            evalPropertyValue = this.getDynamicValue(\n              unEvalPropertyValue,\n              contextTree,\n              oldConfigTree,\n              evaluationSubstitutionType,\n              contextData,\n              undefined,\n              fullPropertyPath,\n              evalContextCache,\n            );\n          } catch (error) {\n            this.errors.push({\n              type: EvalErrorTypes.EVAL_PROPERTY_ERROR,\n              message: (error as Error).message,\n              context: {\n                propertyPath: fullPropertyPath,\n              },\n            });\n            evalPropertyValue = undefined;\n          }\n        } else {\n          evalPropertyValue = unEvalPropertyValue;\n        }\n\n        this.updateUndefinedEvalValuesMap(\n          this.undefinedEvalValuesMap,\n          evalPropertyValue,\n          fullPropertyPath,\n        );\n\n        const entityType = entity.ENTITY_TYPE;\n\n        if (!propertyPath) continue;\n\n        switch (entityType) {\n          case ENTITY_TYPE.WIDGET: {\n            if (isATriggerPath) continue;\n\n            const isNewWidget =\n              isFirstTree || isNewEntity(allNewEntityDiffSet, entityName);\n\n            const widgetEntity = entity as WidgetEntity;\n\n            let parsedValue = validateAndParseWidgetProperty({\n              fullPropertyPath,\n              widget: widgetEntity,\n              configTree: oldConfigTree,\n              evalPropertyValue,\n              unEvalPropertyValue,\n              evalProps: this.evalProps,\n            });\n\n            parsedValue = this.getParsedValueForWidgetProperty({\n              currentTree: contextTree,\n              configTree: oldConfigTree,\n              entity: widgetEntity,\n              evalMetaUpdates,\n              fullPropertyPath,\n              parsedValue,\n              propertyPath,\n              isNewWidget,\n              safeTree,\n            });\n\n            // setting evalPropertyValue in unParsedEvalTree\n            set(\n              this.getUnParsedEvalTree(),\n              fullPropertyPath,\n              evalPropertyValue,\n            );\n\n            set(contextTree, fullPropertyPath, parsedValue);\n            set(safeTree, fullPropertyPath, klonaJSON(parsedValue));\n\n            if (\n              WorkerEnv.flags.release_evaluation_scope_cache &&\n              evalContextCache\n            ) {\n              set(evalContextCache, fullPropertyPath, klonaJSON(parsedValue));\n            }\n\n            staleMetaIds = staleMetaIds.concat(\n              getStaleMetaStateIds({\n                entity: widgetEntity,\n                entityConfig: entityConfig as WidgetEntityConfig,\n                propertyPath,\n                isNewWidget,\n                metaWidgets,\n              }),\n            );\n            break;\n          }\n          case ENTITY_TYPE.ACTION: {\n            const actionEntity = entity as ActionEntity;\n\n            const configProperty = propertyPath.replace(\n              \"config\",\n              \"actionConfiguration\",\n            );\n            const validationConfig =\n              this.allActionValidationConfig?.[actionEntity.actionId]?.[\n                configProperty\n              ];\n\n            this.validateActionProperty(\n              fullPropertyPath,\n              actionEntity,\n              contextTree,\n              evalPropertyValue,\n              unEvalPropertyValue,\n              oldConfigTree,\n              validationConfig,\n            );\n\n            if (!propertyPath) continue;\n\n            /**\n             * Perf optimization very specific to handling actions\n             * Fields like Api1.data doesn't get evaluated since it is not in dynamicBindingPathList\n             * Action validation only captures validation error and doesn't transform the evaluated values.\n             * This means that the values we are looking to set back in the 2 dataTrees are already there.\n             */\n            if (!requiresEval) continue;\n\n            set(contextTree, fullPropertyPath, evalPropertyValue);\n            set(safeTree, fullPropertyPath, klonaJSON(evalPropertyValue));\n\n            if (\n              WorkerEnv.flags.release_evaluation_scope_cache &&\n              evalContextCache\n            ) {\n              set(\n                evalContextCache,\n                fullPropertyPath,\n                klonaJSON(evalPropertyValue),\n              );\n            }\n\n            break;\n          }\n          case ENTITY_TYPE.JSACTION: {\n            const variableList =\n              (entityConfig as JSActionEntityConfig).variables || [];\n\n            if (variableList.indexOf(propertyPath) === -1) break;\n\n            const prevEvaluatedValue = get(\n              this.evalProps,\n              getEvalValuePath(fullPropertyPath, {\n                isPopulated: true,\n                fullPath: true,\n              }),\n            );\n\n            const prevUnEvalValue = JSObjectCollection.getPrevUnEvalState({\n              fullPath: fullPropertyPath,\n            });\n\n            const hasUnEvalValueModified = !isEqual(\n              prevUnEvalValue,\n              unEvalPropertyValue,\n            );\n\n            const skipVariableValueAssignment =\n              !hasUnEvalValueModified && prevEvaluatedValue;\n\n            const evalValue = skipVariableValueAssignment\n              ? prevEvaluatedValue\n              : evalPropertyValue;\n\n            /** Variables defined in a JS object are not reactive.\n             * Their evaluated values need to be reset only when the variable is modified by the user.\n             * When uneval value of a js variable hasn't changed, it means that the previously evaluated values are in both trees already  */\n            if (!skipVariableValueAssignment) {\n              const valueForSafeTree = klonaJSON(evalValue);\n\n              set(contextTree, fullPropertyPath, evalValue);\n              set(safeTree, fullPropertyPath, valueForSafeTree);\n\n              if (\n                WorkerEnv.flags.release_evaluation_scope_cache &&\n                evalContextCache\n              ) {\n                set(\n                  evalContextCache,\n                  fullPropertyPath,\n                  klonaJSON(evalPropertyValue),\n                );\n              }\n\n              JSObjectCollection.setVariableValue(evalValue, fullPropertyPath);\n              JSObjectCollection.setPrevUnEvalState({\n                fullPath: fullPropertyPath,\n                unEvalValue: unEvalPropertyValue,\n              });\n            }\n\n            break;\n          }\n          default:\n            set(contextTree, fullPropertyPath, evalPropertyValue);\n            set(safeTree, fullPropertyPath, klonaJSON(evalPropertyValue));\n\n            if (\n              WorkerEnv.flags.release_evaluation_scope_cache &&\n              evalContextCache\n            ) {\n              set(\n                evalContextCache,\n                fullPropertyPath,\n                klonaJSON(evalPropertyValue),\n              );\n            }\n        }\n      }\n    } catch (error) {\n      staleMetaIds = [];\n      this.errors.push({\n        type: EvalErrorTypes.EVAL_TREE_ERROR,\n        message: (error as Error).message,\n      });\n    } finally {\n      // Restore the dataStore since it was a part of contextTree and prone to mutation.\n      DataStore.replaceDataStore(dataStoreClone);\n\n      // The below statement restores the execution context for async tasks are probably queued.\n      setEvalContext({\n        dataTree: contextTree,\n        configTree: oldConfigTree,\n        isDataField: false,\n        isTriggerBased: true,\n      });\n\n      return {\n        evaluatedTree: safeTree,\n        contextTree: contextTree,\n        evalMetaUpdates,\n        staleMetaIds,\n      };\n    }\n  }\n\n  updateUndefinedEvalValuesMap(\n    undefinedEvalValuesMap: Record<string, boolean>,\n    evalPropertyValue: unknown,\n    fullPropertyPath: string,\n  ) {\n    if (isUndefined(evalPropertyValue)) {\n      undefinedEvalValuesMap[fullPropertyPath] = true;\n    } else if (\n      fullPropertyPath in undefinedEvalValuesMap &&\n      !isUndefined(undefinedEvalValuesMap[fullPropertyPath])\n    ) {\n      delete undefinedEvalValuesMap[fullPropertyPath];\n    }\n  }\n\n  setAllActionValidationConfig(allActionValidationConfig: {\n    [actionId: string]: ActionValidationConfigMap;\n  }): void {\n    this.allActionValidationConfig = allActionValidationConfig;\n  }\n\n  sortDependencies(\n    dependencyMap: DependencyMap,\n    diffs?: DataTreeDiff[],\n  ): Array<string> {\n    const result = DependencyMapUtils.sortDependencies(dependencyMap);\n\n    if (result.success) {\n      return result.sortedDependencies;\n    } else {\n      const node = result.cyclicNode;\n      let entityType = \"UNKNOWN\";\n      const entityName = node.split(\".\")[0];\n      const entity = get(this.oldUnEvalTree, entityName) as DataTreeEntity;\n      const entityConfig = get(this.oldConfigTree, entityName);\n\n      if (entity && isWidget(entity)) {\n        entityType = entity.type;\n      } else if (entity && isAction(entity)) {\n        const actionEntityConfig = entityConfig as ActionEntityConfig;\n\n        entityType = actionEntityConfig.pluginType;\n      } else if (entity && isJSAction(entity)) {\n        entityType = entity.ENTITY_TYPE;\n      }\n\n      const dependencies = dependencyMap.dependencies;\n\n      // We are only interested in logging potential system-generated cyclic dependency errors to Sentry\n      // If a cyclic dependency error occurs without a user editing a dynamic field, that is a potential system-generated cyclic dependency error\n\n      const logToSentry = !diffs\n        ? false\n        : !diffs.some((val) => val.event === DataTreeDiffEvent.EDIT);\n\n      this.errors.push({\n        type: EvalErrorTypes.CYCLICAL_DEPENDENCY_ERROR,\n        message: \"Cyclic dependency found while evaluating.\",\n        context: {\n          node,\n          entityType,\n          dependencyMap: dependencies,\n          diffs,\n          logToSentry,\n        },\n      });\n      logError(\"CYCLICAL DEPENDENCY MAP\", dependencies);\n      this.hasCyclicalDependency = true;\n      throw new CrashingError((result.error as Error).message);\n    }\n  }\n\n  getDynamicValue(\n    dynamicBinding: string,\n    data: DataTree,\n    configTree: ConfigTree,\n    evaluationSubstitutionType: EvaluationSubstitutionType,\n    contextData?: EvaluateContext,\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callBackData?: Array<any>,\n    fullPropertyPath?: string,\n    evalContextCache?: EvaluateContext,\n  ) {\n    // Get the {{binding}} bound values\n    let entity: DataTreeEntity | undefined = undefined;\n    let entityConfig: DataTreeEntityConfig | undefined = undefined;\n    let propertyPath: string;\n\n    if (fullPropertyPath) {\n      const entityName = fullPropertyPath.split(\".\")[0];\n\n      propertyPath = fullPropertyPath.split(\".\")[1];\n      entity = data[entityName];\n      entityConfig = configTree[entityName];\n    }\n\n    // Get the {{binding}} bound values\n    const { jsSnippets, stringSegments } = getDynamicBindings(\n      dynamicBinding,\n      entity,\n    );\n\n    if (stringSegments.length) {\n      // Get the Data Tree value of those \"binding \"paths\n      const values = jsSnippets.map((jsSnippet, index) => {\n        const toBeSentForEval =\n          entity && isJSAction(entity) && propertyPath === \"body\"\n            ? jsSnippet.replace(/export default/g, \"\")\n            : jsSnippet;\n\n        if (!jsSnippet) return stringSegments[index];\n\n        if (entity && entityConfig && !propertyPath.includes(\"body\")) {\n          ExecutionMetaData.setExecutionMetaData({\n            triggerMeta: {\n              source: {\n                id: getEntityId(entity) || \"\",\n                entityType: entity.ENTITY_TYPE,\n                name: getEntityName(entity, entityConfig) || \"\",\n              },\n              triggerPropertyName: fullPropertyPath?.split(\".\")[1] || \"\",\n              onPageLoad: false,\n            },\n          });\n        }\n\n        const { errors: evalErrors, result } = this.evaluateDynamicBoundValue(\n          toBeSentForEval,\n          data,\n          !!entity && isAnyJSAction(entity),\n          contextData,\n          callBackData,\n          evalContextCache,\n        );\n\n        if (fullPropertyPath && evalErrors.length) {\n          addErrorToEntityProperty({\n            errors: errorModifier.addRootcauseToAsyncInvocationErrors(\n              fullPropertyPath,\n              configTree,\n              evalErrors,\n              this.dependencyMap,\n            ),\n            evalProps: this.evalProps,\n            fullPropertyPath,\n            configTree,\n          });\n        }\n\n        return result;\n      });\n\n      // We don't need to substitute template of the result if only one binding exists\n      // But it should not be of prepared statements since that does need a string\n      if (\n        stringSegments.length === 1 &&\n        evaluationSubstitutionType !== EvaluationSubstitutionType.PARAMETER\n      ) {\n        return values[0];\n      }\n\n      try {\n        // else return a combined value according to the evaluation type\n        return substituteDynamicBindingWithValues(\n          dynamicBinding,\n          stringSegments,\n          values,\n          evaluationSubstitutionType,\n        );\n      } catch (error) {\n        if (fullPropertyPath) {\n          addErrorToEntityProperty({\n            errors: [\n              {\n                raw: dynamicBinding,\n                errorType: PropertyEvaluationErrorType.PARSE,\n                errorMessage: {\n                  name: (error as Error).name,\n                  message: (error as Error).message,\n                },\n                severity: Severity.ERROR,\n              },\n            ],\n            evalProps: this.evalProps,\n            fullPropertyPath,\n            configTree,\n          });\n        }\n      }\n    }\n  }\n\n  async evaluateTriggers(\n    userScript: string,\n    dataTree: DataTree,\n    configTree: ConfigTree,\n    callbackData: Array<unknown>,\n    context?: EvaluateContext,\n  ) {\n    const isDynamic = isDynamicValue(userScript);\n    const { jsSnippets } = getDynamicBindings(userScript);\n\n    return evaluateAsync(\n      /**\n       * jsSnippets[0] will be \"\" when a JS Object's function is run manually or when an empty action for a trigger field is configured.\n       * Eg. Button1.onClick = \"{{}}\"\n       * isDynamic will be false for JSObject's function run but will be true for action bindings.\n       */\n      isDynamic ? jsSnippets[0] : userScript,\n      dataTree,\n      configTree,\n      context,\n      callbackData,\n    );\n  }\n\n  // Paths are expected to have \"{name}.{path}\" signature\n  // Also returns any action triggers found after evaluating value\n  evaluateDynamicBoundValue(\n    js: string,\n    data: DataTree,\n    isJSObject: boolean,\n    contextData?: EvaluateContext,\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    callbackData?: Array<any>,\n    evalContextCache?: EvaluateContext,\n  ): EvalResult {\n    let evalResponse: EvalResult;\n\n    ExecutionMetaData.setExecutionMetaData({\n      enableJSVarUpdateTracking: false,\n      enableJSFnPostProcessors: false,\n    });\n    try {\n      evalResponse = evaluateSync(\n        js,\n        data,\n        isJSObject,\n        contextData,\n        callbackData,\n        {},\n        evalContextCache,\n      );\n    } catch (error) {\n      evalResponse = {\n        result: undefined,\n        errors: [\n          {\n            errorType: PropertyEvaluationErrorType.PARSE,\n            raw: js,\n            severity: Severity.ERROR,\n            errorMessage: {\n              name: (error as Error).name,\n              message: (error as Error).message,\n            },\n          },\n        ],\n      };\n    }\n    ExecutionMetaData.setExecutionMetaData({\n      enableJSVarUpdateTracking: true,\n      enableJSFnPostProcessors: true,\n    });\n\n    return evalResponse;\n  }\n\n  getParsedValueForWidgetProperty({\n    configTree,\n    currentTree,\n    entity,\n    evalMetaUpdates,\n    fullPropertyPath,\n    isNewWidget,\n    parsedValue,\n    propertyPath,\n    safeTree,\n  }: {\n    currentTree: DataTree;\n    configTree: ConfigTree;\n    entity: WidgetEntity;\n    evalMetaUpdates: EvalMetaUpdates;\n    fullPropertyPath: string;\n    isNewWidget: boolean;\n    parsedValue: unknown;\n    propertyPath: string;\n    safeTree?: DataTree;\n  }) {\n    const overwriteObj = overrideWidgetProperties({\n      entity,\n      propertyPath,\n      value: parsedValue,\n      currentTree,\n      configTree,\n      evalMetaUpdates,\n      fullPropertyPath,\n      isNewWidget,\n      safeTree,\n    });\n\n    if (overwriteObj && overwriteObj.overwriteParsedValue) {\n      parsedValue = overwriteObj.newValue;\n    }\n\n    return parsedValue;\n  }\n\n  // validates the user input saved as action property based on a validationConfig\n  validateActionProperty(\n    fullPropertyPath: string,\n    action: ActionEntity,\n    currentTree: DataTree,\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    evalPropertyValue: any,\n    unEvalPropertyValue: string,\n    configTree: ConfigTree,\n    validationConfig?: ValidationConfig,\n  ) {\n    if (!evalPropertyValue || isEmpty(validationConfig)) return;\n\n    // runs VALIDATOR function and returns errors\n    const { isValid, messages } = validateActionProperty(\n      validationConfig,\n      evalPropertyValue,\n    );\n\n    if (isValid) return;\n\n    resetValidationErrorsForEntityProperty({\n      evalProps: this.evalProps,\n      fullPropertyPath,\n    });\n    const evalErrors: EvaluationError[] =\n      messages?.map((message) => {\n        return {\n          raw: unEvalPropertyValue,\n          errorMessage: message || { name: \"\", text: \"\" },\n          errorType: PropertyEvaluationErrorType.VALIDATION,\n          severity: Severity.ERROR,\n        };\n      }) ?? [];\n\n    // saves error in dataTree at fullPropertyPath\n    // Later errors can consumed by the forms and debugger\n    addErrorToEntityProperty({\n      errors: evalErrors,\n      evalProps: this.evalProps,\n      fullPropertyPath,\n      configTree,\n    });\n  }\n\n  /**\n   *\n   * Apply the changes to the eval tree. After this, the evaltree will have unevaluated values for the paths that are getting evaluated. To skip this step, we need to pick unevaluated values during evaluation\n   */\n  updateEvalTreeWithChanges({\n    differences,\n  }: {\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    differences: Diff<any, any>[];\n  }) {\n    for (const d of differences) {\n      if (!Array.isArray(d.path) || d.path.length === 0) continue; // Null check for typescript\n\n      // Apply the changes into the evalTree so that it gets the latest changes\n      applyChange(this.evalTree, undefined, d);\n    }\n  }\n\n  calculateSubTreeSortOrder(\n    updatedValuePaths: string[][],\n    dependenciesOfRemovedPaths: Array<string>,\n    removedPaths: Array<{ entityId: string; fullpath: string }>,\n    unEvalTree: DataTree,\n  ): string[] {\n    const changePaths: Set<string> = new Set(dependenciesOfRemovedPaths);\n    const configTree = this.getConfigTree();\n\n    for (const pathArray of updatedValuePaths) {\n      const fullPropertyPath = convertPathToString(pathArray);\n\n      changePaths.add(fullPropertyPath);\n\n      // If this is a property path change, simply add for evaluation and move on\n      if (!isDynamicLeaf(unEvalTree, fullPropertyPath, configTree)) {\n        // A parent level property has been added or deleted\n        /**\n         * We want to add all pre-existing dynamic and static bindings in dynamic paths of this entity to get evaluated and validated.\n         * Example:\n         * - Table1.tableData = {{Api1.data}}\n         * - Api1 gets created.\n         * - This function gets called with a diff {path:[\"Api1\"]}\n         * We want to add `Api.data` to changedPaths so that `Table1.tableData` can be discovered below.\n         */\n        const entityName = pathArray[0];\n        const entityConfig = configTree[entityName];\n        const entity = unEvalTree[entityName];\n\n        if (!entity || isNotEntity(entity)) {\n          continue;\n        }\n\n        const entityDynamicBindingPathsSet = new Set<string>();\n\n        if (isAction(entity)) {\n          getEntityDynamicBindingPathList(entityConfig).forEach((path) => {\n            entityDynamicBindingPathsSet.add(path.key);\n          });\n        }\n\n        Object.keys(entityConfig.reactivePaths).forEach((reactivePath) => {\n          const childPropertyPath = `${entityName}.${reactivePath}`;\n\n          // Check if relative path has dynamic binding\n          if (entityDynamicBindingPathsSet.has(reactivePath)) {\n            changePaths.add(childPropertyPath);\n          }\n\n          if (isChildPropertyPath(fullPropertyPath, childPropertyPath)) {\n            changePaths.add(childPropertyPath);\n          }\n        });\n      }\n    }\n\n    // If a nested property path has changed and someone (say x) is dependent on the parent of the said property,\n    // x must also be evaluated. For example, the following relationship exists in dependency map:\n    // <  \"Input1.defaultText\" : [\"Table1.selectedRow.email\"] >\n    // If Table1.selectedRow has changed, then Input1.defaultText must also be evaluated because Table1.selectedRow.email\n    // is a nested property of Table1.selectedRow\n    const changePathsWithNestedDependants = addDependantsOfNestedPropertyPaths(\n      Array.from(changePaths),\n      this.inverseDependencies,\n    );\n\n    const trimmedChangedPaths = trimDependantChangePaths(\n      changePathsWithNestedDependants,\n      this.dependencies,\n    );\n\n    // Now that we have all the root nodes which have to be evaluated, recursively find all the other paths which\n    // would get impacted because they are dependent on the said root nodes and add them in order\n    const completeSortOrder = this.getCompleteSortOrder(\n      trimmedChangedPaths,\n      this.inverseDependencies,\n    );\n\n    // Remove any paths that do not exist in the data tree anymore\n    return difference(\n      completeSortOrder,\n      removedPaths.map((removedPath) => removedPath.fullpath),\n    );\n  }\n\n  evaluateActionBindings(\n    bindings: string[],\n    executionParams?: Record<string, unknown> | string,\n  ) {\n    const dataTree = klonaJSON(this.evalTree);\n    // We might get execution params as an object or as a string.\n    // If the user has added a proper object (valid case) it will be an object\n    // If they have not added any execution params or not an object\n    // it would be a string (invalid case)\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let evaluatedExecutionParams: Record<string, any> = {};\n    let overrideContext: Record<string, unknown>;\n\n    if (executionParams && isObject(executionParams)) {\n      evaluatedExecutionParams = this.getDynamicValue(\n        `{{${JSON.stringify(executionParams)}}}`,\n        this.evalTree,\n        this.oldConfigTree,\n        EvaluationSubstitutionType.TEMPLATE,\n      );\n\n      overrideContext = generateOverrideContext({\n        bindings,\n        executionParams,\n        dataTree,\n      });\n    }\n\n    return bindings.map((binding) => {\n      // Replace any reference of 'this.params' to 'executionParams' (backwards compatibility)\n      // also helps with dealing with IIFE which are normal functions (not arrow)\n      // because normal functions won't retain 'this' context (when executed elsewhere)\n      const replacedBinding = binding.replace(\n        EXECUTION_PARAM_REFERENCE_REGEX,\n        EXECUTION_PARAM_KEY,\n      );\n\n      return this.getDynamicValue(\n        `{{${replacedBinding}}}`,\n        dataTree,\n        this.oldConfigTree,\n        EvaluationSubstitutionType.TEMPLATE,\n        // params can be accessed via \"this.params\" or \"executionParams\"\n        {\n          thisContext: {\n            [THIS_DOT_PARAMS_KEY]: evaluatedExecutionParams,\n          },\n          globalContext: {\n            [EXECUTION_PARAM_KEY]: evaluatedExecutionParams,\n          },\n          overrideContext,\n        },\n      );\n    });\n  }\n\n  clearErrors() {\n    this.errors = [];\n  }\n  clearLogs() {\n    this.logs = [];\n  }\n}\n","import { get, isEmpty } from \"lodash\";\nimport { diff as deepDiff } from \"deep-diff\";\nimport type { JSUpdate } from \"utils/JSPaneUtils\";\nimport { dataTreeEvaluator } from \"../handlers/evalTree\";\nimport { getType } from \"utils/TypeHelpers\";\n\ntype JSUpdates = Record<string, JSUpdate>;\n\nlet prevJSUpdates: JSUpdates;\n\nfunction getVariableObject(jsUpdates: JSUpdates) {\n  const prevJSObjects = Object.entries(jsUpdates);\n  const prevJSObjectVar: Record<string, unknown> = {};\n\n  for (const [jsObjectName, jsObjectBody] of prevJSObjects) {\n    const variables = jsObjectBody.parsedBody?.variables;\n\n    if (!variables?.length) continue;\n\n    const varKeyMap: Record<string, string> = {};\n\n    variables.forEach(({ name }) => {\n      varKeyMap[name] = name;\n    });\n    prevJSObjectVar[jsObjectName] = varKeyMap;\n  }\n\n  return prevJSObjectVar;\n}\n\nfunction getVariableDiff(jsUpdates: JSUpdates) {\n  if (isEmpty(jsUpdates)) return;\n\n  if (!prevJSUpdates) {\n    prevJSUpdates = jsUpdates;\n\n    return;\n  }\n\n  const prevJSObjectVar = getVariableObject(prevJSUpdates);\n  const jsObjectVar = getVariableObject(jsUpdates);\n  const diff = deepDiff(prevJSObjectVar, jsObjectVar);\n\n  prevJSUpdates = jsUpdates;\n\n  return diff;\n}\n\nexport function getJSVariableCreatedEvents(jsUpdates: JSUpdates) {\n  const jsVarDiff = getVariableDiff(jsUpdates);\n\n  const jsVarsCreated: { path: string; type: string }[] = [];\n\n  jsVarDiff?.forEach((diff) => {\n    if (diff.kind === \"N\" && diff.path?.length === 2) {\n      const evalTree = dataTreeEvaluator?.getEvalTree() || {};\n      const value = get(evalTree, diff.path);\n      const type = getType(value);\n\n      jsVarsCreated.push({ path: diff.path?.join(\".\"), type });\n    }\n  });\n\n  return jsVarsCreated;\n}\n","import type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport type ReplayEntity from \"entities/Replay\";\nimport ReplayCanvas from \"entities/Replay/ReplayEntity/ReplayCanvas\";\nimport { isEmpty } from \"lodash\";\nimport type { DependencyMap, EvalError } from \"utils/DynamicBindingUtils\";\nimport { EvalErrorTypes } from \"utils/DynamicBindingUtils\";\nimport type { JSUpdate } from \"utils/JSPaneUtils\";\nimport DataTreeEvaluator from \"workers/common/DataTreeEvaluator\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport { makeEntityConfigsAsObjProperties } from \"ee/workers/Evaluation/dataTreeUtils\";\nimport type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport { serialiseToBigInt } from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  CrashingError,\n  getSafeToRenderDataTree,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { EvalTreeRequestData, EvalWorkerASyncRequest } from \"../types\";\nimport { clearAllIntervals } from \"../fns/overrides/interval\";\nimport JSObjectCollection from \"workers/Evaluation/JSObject/Collection\";\nimport { getJSVariableCreatedEvents } from \"../JSObject/JSVariableEvents\";\nimport { errorModifier } from \"../errorModifier\";\nimport {\n  generateOptimisedUpdatesAndSetPrevState,\n  uniqueOrderUpdatePaths,\n} from \"../helpers\";\nimport DataStore from \"../dataStore\";\nimport type { TransmissionErrorHandler } from \"../fns/utils/Messenger\";\nimport { MessageType, sendMessage } from \"utils/MessageUtil\";\nimport {\n  profileFn,\n  newWebWorkerSpanData,\n  profileAsyncFn,\n} from \"instrumentation/generateWebWorkerTraces\";\nimport type { CanvasWidgetsReduxState } from \"ee/reducers/entityReducers/canvasWidgetsReducer\";\nimport type { MetaWidgetsReduxState } from \"reducers/entityReducers/metaWidgetsReducer\";\nimport type { Attributes } from \"instrumentation/types\";\nimport { updateActionsToEvalTree } from \"./updateActionData\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport let replayMap: Record<string, ReplayEntity<any>> | undefined;\nexport let dataTreeEvaluator: DataTreeEvaluator | undefined;\nexport const CANVAS = \"canvas\";\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport let canvasWidgetsMeta: Record<string, any>;\nexport let metaWidgetsCache: MetaWidgetsReduxState;\nexport let canvasWidgets: CanvasWidgetsReduxState;\n\nexport async function evalTree(\n  request: EvalWorkerASyncRequest<EvalTreeRequestData>,\n) {\n  const { data, webworkerTelemetry } = request;\n\n  webworkerTelemetry[\"transferDataToWorkerThread\"].endTime = Date.now();\n\n  let evalOrder: string[] = [];\n  let jsUpdates: Record<string, JSUpdate> = {};\n  let unEvalUpdates: DataTreeDiff[] = [];\n  let isCreateFirstTree = false;\n  let dataTree: DataTree = {};\n  let errors: EvalError[] = [];\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let logs: any[] = [];\n  let dependencies: DependencyMap = {};\n  let evalMetaUpdates: EvalMetaUpdates = [];\n  let configTree: ConfigTree = {};\n  let staleMetaIds: string[] = [];\n  let removedPaths: Array<{ entityId: string; fullpath: string }> = [];\n  let isNewWidgetAdded = false;\n\n  const {\n    actionDataPayloadConsolidated,\n    affectedJSObjects,\n    allActionValidationConfig,\n    appMode,\n    cacheProps,\n    forceEvaluation,\n    metaWidgets,\n    shouldReplay,\n    shouldRespondWithLogs,\n    theme,\n    unevalTree: __unevalTree__,\n    widgets,\n    widgetsMeta,\n    widgetTypeConfigMap,\n  } = data;\n\n  const unevalTree = __unevalTree__.unEvalTree;\n\n  configTree = __unevalTree__.configTree as ConfigTree;\n  canvasWidgets = widgets;\n  canvasWidgetsMeta = widgetsMeta;\n  metaWidgetsCache = metaWidgets;\n  let isNewTree = false;\n\n  try {\n    (webworkerTelemetry.__spanAttributes as Attributes)[\"firstEvaluation\"] =\n      !dataTreeEvaluator;\n\n    if (!dataTreeEvaluator) {\n      isCreateFirstTree = true;\n      replayMap = replayMap || {};\n      replayMap[CANVAS] = new ReplayCanvas({ widgets, theme });\n      errorModifier.init(appMode);\n      dataTreeEvaluator = new DataTreeEvaluator(\n        widgetTypeConfigMap,\n        allActionValidationConfig,\n      );\n\n      const setupFirstTreeResponse = await profileAsyncFn(\n        \"setupFirstTree\",\n        (dataTreeEvaluator as DataTreeEvaluator).setupFirstTree.bind(\n          dataTreeEvaluator,\n          unevalTree,\n          configTree,\n          webworkerTelemetry,\n          cacheProps,\n        ),\n        webworkerTelemetry,\n        { description: \"during initialisation\" },\n      );\n\n      evalOrder = setupFirstTreeResponse.evalOrder;\n      jsUpdates = setupFirstTreeResponse.jsUpdates;\n\n      const dataTreeResponse = profileFn(\n        \"evalAndValidateFirstTree\",\n        { description: \"during initialisation\" },\n        webworkerTelemetry,\n        (dataTreeEvaluator as DataTreeEvaluator).evalAndValidateFirstTree.bind(\n          dataTreeEvaluator,\n        ),\n      );\n\n      dataTree = makeEntityConfigsAsObjProperties(dataTreeResponse.evalTree, {\n        evalProps: dataTreeEvaluator.evalProps,\n      });\n      staleMetaIds = dataTreeResponse.staleMetaIds;\n      isNewTree = true;\n    } else if (dataTreeEvaluator.hasCyclicalDependency || forceEvaluation) {\n      if (dataTreeEvaluator && !isEmpty(allActionValidationConfig)) {\n        //allActionValidationConfigs may not be set in dataTreeEvaluator. Therefore, set it explicitly via setter method\n        dataTreeEvaluator.setAllActionValidationConfig(\n          allActionValidationConfig,\n        );\n      }\n\n      if (shouldReplay && replayMap) {\n        replayMap[CANVAS]?.update({ widgets, theme });\n      }\n\n      dataTreeEvaluator = new DataTreeEvaluator(\n        widgetTypeConfigMap,\n        allActionValidationConfig,\n      );\n\n      if (dataTreeEvaluator && !isEmpty(allActionValidationConfig)) {\n        dataTreeEvaluator.setAllActionValidationConfig(\n          allActionValidationConfig,\n        );\n      }\n\n      const setupFirstTreeResponse = await profileAsyncFn(\n        \"setupFirstTree\",\n        (dataTreeEvaluator as DataTreeEvaluator).setupFirstTree.bind(\n          dataTreeEvaluator,\n          unevalTree,\n          configTree,\n          webworkerTelemetry,\n          cacheProps,\n        ),\n        webworkerTelemetry,\n        { description: \"non-initialisation\" },\n      );\n\n      isCreateFirstTree = true;\n      evalOrder = setupFirstTreeResponse.evalOrder;\n      jsUpdates = setupFirstTreeResponse.jsUpdates;\n\n      const dataTreeResponse = profileFn(\n        \"evalAndValidateFirstTree\",\n        { description: \"non-initialisation\" },\n        webworkerTelemetry,\n        () =>\n          (dataTreeEvaluator as DataTreeEvaluator).evalAndValidateFirstTree(),\n      );\n\n      dataTree = makeEntityConfigsAsObjProperties(dataTreeResponse.evalTree, {\n        evalProps: dataTreeEvaluator.evalProps,\n      });\n      staleMetaIds = dataTreeResponse.staleMetaIds;\n    } else {\n      const tree = dataTreeEvaluator.getEvalTree();\n\n      // during update cycles update actions to the dataTree directly\n      // this is useful in cases where we have debounced updateActionData and a regular evaluation\n      // triggered together, in those cases we merge them both into a regular evaluation\n      updateActionsToEvalTree(tree, actionDataPayloadConsolidated);\n\n      if (dataTreeEvaluator && !isEmpty(allActionValidationConfig)) {\n        dataTreeEvaluator.setAllActionValidationConfig(\n          allActionValidationConfig,\n        );\n      }\n\n      isCreateFirstTree = false;\n\n      if (shouldReplay && replayMap) {\n        replayMap[CANVAS]?.update({ widgets, theme });\n      }\n\n      const setupUpdateTreeResponse = profileFn(\n        \"setupUpdateTree\",\n        undefined,\n        webworkerTelemetry,\n        () =>\n          (dataTreeEvaluator as DataTreeEvaluator).setupUpdateTree(\n            unevalTree,\n            configTree,\n            webworkerTelemetry,\n            affectedJSObjects,\n            actionDataPayloadConsolidated,\n          ),\n      );\n\n      evalOrder = setupUpdateTreeResponse.evalOrder;\n      jsUpdates = setupUpdateTreeResponse.jsUpdates;\n      unEvalUpdates = setupUpdateTreeResponse.unEvalUpdates;\n      removedPaths = setupUpdateTreeResponse.removedPaths;\n      isNewWidgetAdded = setupUpdateTreeResponse.isNewWidgetAdded;\n\n      const updateResponse = profileFn(\n        \"evalAndValidateSubTree\",\n        undefined,\n        webworkerTelemetry,\n        () =>\n          (dataTreeEvaluator as DataTreeEvaluator).evalAndValidateSubTree(\n            evalOrder,\n            configTree,\n            unEvalUpdates,\n            Object.keys(metaWidgets),\n          ),\n      );\n\n      dataTree = makeEntityConfigsAsObjProperties(dataTreeEvaluator.evalTree, {\n        evalProps: dataTreeEvaluator.evalProps,\n      });\n\n      evalMetaUpdates = JSON.parse(\n        JSON.stringify(updateResponse.evalMetaUpdates),\n      );\n      staleMetaIds = updateResponse.staleMetaIds;\n    }\n\n    dependencies = dataTreeEvaluator.inverseDependencies;\n    errors = dataTreeEvaluator.errors;\n    dataTreeEvaluator.clearErrors();\n    logs = dataTreeEvaluator.logs;\n\n    if (shouldReplay && replayMap) {\n      if (replayMap[CANVAS]?.logs) logs = logs.concat(replayMap[CANVAS]?.logs);\n\n      replayMap[CANVAS]?.clearLogs();\n    }\n\n    dataTreeEvaluator.clearLogs();\n  } catch (error) {\n    if (dataTreeEvaluator !== undefined) {\n      errors = dataTreeEvaluator.errors;\n      logs = dataTreeEvaluator.logs;\n    }\n\n    if (!(error instanceof CrashingError)) {\n      errors.push({\n        type: EvalErrorTypes.UNKNOWN_ERROR,\n        message: (error as Error).message,\n      });\n      // eslint-disable-next-line\n      console.error(error);\n    }\n\n    dataTree = getSafeToRenderDataTree(\n      makeEntityConfigsAsObjProperties(unevalTree, {\n        sanitizeDataTree: false,\n        evalProps: dataTreeEvaluator?.evalProps,\n      }),\n      widgetTypeConfigMap,\n      configTree,\n    );\n    unEvalUpdates = [];\n    isNewTree = true;\n  }\n\n  const jsVarsCreatedEvent = getJSVariableCreatedEvents(jsUpdates);\n\n  const updates = profileFn(\n    \"diffAndGenerateSerializeUpdates\",\n    undefined,\n    webworkerTelemetry,\n    () => {\n      let updates;\n\n      if (isNewTree) {\n        try {\n          //for new tree send the whole thing, don't diff at all\n          updates = serialiseToBigInt([{ kind: \"newTree\", rhs: dataTree }]);\n          dataTreeEvaluator?.setPrevState(dataTree);\n        } catch (e) {\n          updates = \"[]\";\n        }\n        isNewTree = false;\n      } else {\n        const allUnevalUpdates = unEvalUpdates.map(\n          (update) => update.payload.propertyPath,\n        );\n\n        const completeEvalOrder = uniqueOrderUpdatePaths([\n          ...allUnevalUpdates,\n          ...evalOrder,\n        ]);\n\n        updates = generateOptimisedUpdatesAndSetPrevState(\n          dataTree,\n          dataTreeEvaluator,\n          completeEvalOrder,\n        );\n      }\n\n      return updates;\n    },\n  );\n\n  const evalTreeResponse = {\n    updates,\n    dependencies,\n    errors,\n    evalMetaUpdates,\n    evaluationOrder: evalOrder,\n    jsUpdates,\n    webworkerTelemetry,\n    // be weary of the payload size of logs it can be huge and contribute to transmission overhead\n    // we are only sending logs in local debug mode\n    logs: shouldRespondWithLogs ? logs : [],\n    unEvalUpdates,\n    isCreateFirstTree,\n    staleMetaIds,\n    removedPaths,\n    isNewWidgetAdded,\n    undefinedEvalValuesMap: dataTreeEvaluator?.undefinedEvalValuesMap || {},\n    jsVarsCreatedEvent,\n  };\n\n  webworkerTelemetry[\"transferDataToMainThread\"] = newWebWorkerSpanData(\n    \"transferDataToMainThread\",\n    {},\n  );\n\n  return evalTreeResponse;\n}\n\nexport const evalTreeTransmissionErrorHandler: TransmissionErrorHandler = (\n  messageId: string,\n  startTime: number,\n  endTime: number,\n  responseData: unknown,\n) => {\n  const sanitizedData = JSON.parse(JSON.stringify(responseData));\n\n  sendMessage.call(self, {\n    messageId,\n    messageType: MessageType.RESPONSE,\n    body: { data: sanitizedData, startTime, endTime },\n  });\n};\n\nexport function clearCache() {\n  dataTreeEvaluator = undefined;\n  clearAllIntervals();\n  JSObjectCollection.clear();\n  DataStore.clear();\n\n  return true;\n}\n","import type {\n  DynamicValues,\n  EvaluatedFormConfig,\n  FormEvalOutput,\n  FormEvaluationState,\n  FormConfigEvalObject,\n  DynamicValuesConfig,\n} from \"reducers/evaluationReducers/formEvaluationReducer\";\nimport { ReduxActionTypes } from \"ee/constants/ReduxActionConstants\";\nimport type { ActionConfig } from \"entities/Action\";\nimport type { FormEvalActionPayload } from \"sagas/FormEvaluationSaga\";\nimport type { FormConfigType } from \"components/formControls/BaseControl\";\nimport { isArray, isEmpty, isString, merge, uniq } from \"lodash\";\nimport { extractEvalConfigFromFormConfig } from \"components/formControls/utils\";\nimport { isDynamicValue } from \"utils/DynamicBindingUtils\";\nimport { isTrueObject } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { DatasourceConfiguration } from \"entities/Datasource\";\nimport { objectKeys } from \"@appsmith/utils\";\nimport {\n  ActionParentEntityType,\n  type ActionParentEntityTypeInterface,\n} from \"ee/entities/Engine/actionHelpers\";\n\nexport enum ConditionType {\n  HIDE = \"hide\", // When set, the component will be shown until condition is true\n  SHOW = \"show\", // When set, the component will be hidden until condition is true\n  ENABLE = \"enable\", // When set, the component will be enabled until condition is true\n  DISABLE = \"disable\", // When set, the component will be disabled until condition is true\n  FETCH_DYNAMIC_VALUES = \"fetchDynamicValues\", // When set, the component will fetch the values dynamically\n  EVALUATE_FORM_CONFIG = \"evaluateFormConfig\", // When set, the component will evaluate the form config settings\n}\n\nexport enum FormDataPaths {\n  COMMAND = \"actionConfiguration.formData.command.data\",\n  ENTITY_TYPE = \"actionConfiguration.formData.entityType.data\",\n}\n\n// Object to hold the initial eval object\nlet finalEvalObj: FormEvalOutput;\n\n// This variable, holds an array of strings that represent the path for the evalConfigs.\n// This path os used to configure the evalFormConfig objects for various form configs\nlet evalConfigPaths: string[] = [];\n\n// This regex matches the config property string up to countless places.\nexport const MATCH_ACTION_CONFIG_PROPERTY =\n  /\\b(actionConfiguration\\.\\w+.(?:(\\w+.)){1,})\\b/g;\nexport function matchExact(r: RegExp, str: string) {\n  const match = str.match(r);\n\n  return match || [];\n}\n\n// Recursive function to generate the evaluation state for form config\nconst generateInitialEvalState = (formConfig: FormConfigType) => {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const conditionals: Record<string, any> = {};\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const conditionTypes: Record<string, any> = {};\n  let dependencyPaths: string[] = [];\n\n  // // Any element is only added to the eval state if they have a conditional statement present, if not they are allowed to be rendered\n  // if (\"conditionals\" in formConfig && !!formConfig.conditionals) {\n  let key = \"unknowns\";\n\n  // A unique key is used to refer the object in the eval state, can be propertyName, configProperty or identifier\n  if (\"propertyName\" in formConfig && !!formConfig.propertyName) {\n    key = formConfig.propertyName;\n  } else if (\"configProperty\" in formConfig && !!formConfig.configProperty) {\n    key = formConfig.configProperty;\n  } else if (\"identifier\" in formConfig && !!formConfig.identifier) {\n    key = formConfig.identifier;\n  }\n\n  // Any element is only added to the eval state if they have a conditional statement present, if not they are allowed to be rendered\n  if (\"conditionals\" in formConfig && !!formConfig.conditionals) {\n    const allConditionTypes = objectKeys(formConfig.conditionals);\n\n    if (\n      allConditionTypes.includes(ConditionType.HIDE) ||\n      allConditionTypes.includes(ConditionType.SHOW)\n    ) {\n      conditionTypes.visible = false;\n      merge(conditionals, formConfig.conditionals);\n\n      const showOrHideDependencies = matchExact(\n        MATCH_ACTION_CONFIG_PROPERTY,\n        formConfig.conditionals?.show || formConfig.conditionals?.hide || \"\",\n      );\n\n      dependencyPaths = [...dependencyPaths, ...showOrHideDependencies];\n    }\n\n    if (\n      allConditionTypes.includes(ConditionType.ENABLE) ||\n      allConditionTypes.includes(ConditionType.DISABLE)\n    ) {\n      conditionTypes.enabled = true;\n      merge(conditionals, formConfig.conditionals);\n\n      const enableOrDisableDependencies = matchExact(\n        MATCH_ACTION_CONFIG_PROPERTY,\n        formConfig.conditionals?.enable ||\n          formConfig.conditionals?.disable ||\n          \"\",\n      );\n\n      dependencyPaths = [...dependencyPaths, ...enableOrDisableDependencies];\n    }\n\n    // if (allConditionTypes.includes(ConditionType.EVALUATE_FORM_CONFIG)) {\n    //   // Setting the component as invisible since it has elements that will be evaluated later\n    //   conditionTypes.visible = false;\n    //   const evaluateFormConfig: EvaluatedFormConfig = {\n    //     updateEvaluatedConfig: false,\n    //     paths: formConfig.conditionals.evaluateFormConfig.paths,\n    //     evaluateFormConfigObject: extractEvalConfigFromFormConfig(\n    //       formConfig,\n    //       formConfig.conditionals.evaluateFormConfig.paths,\n    //     ),\n    //   };\n    //   conditionTypes.evaluateFormConfig = evaluateFormConfig;\n    //   conditionals.evaluateFormConfig =\n    //     formConfig.conditionals.evaluateFormConfig.condition;\n    // }\n\n    if (allConditionTypes.includes(ConditionType.FETCH_DYNAMIC_VALUES)) {\n      const fetchDynamicValuesDependencies = matchExact(\n        MATCH_ACTION_CONFIG_PROPERTY,\n        formConfig.conditionals?.fetchDynamicValues?.condition || \"\",\n      );\n      let dynamicDependencyPathList: Set<string> | undefined;\n\n      if (fetchDynamicValuesDependencies.length > 0) {\n        dynamicDependencyPathList = new Set(fetchDynamicValuesDependencies);\n      } else {\n        dynamicDependencyPathList = undefined;\n      }\n\n      const dynamicValues: DynamicValues = {\n        allowedToFetch: false,\n        isLoading: false,\n        hasStarted: false,\n        hasFetchFailed: false,\n        data: [],\n        config: formConfig.conditionals.fetchDynamicValues.config,\n        dynamicDependencyPathList,\n        evaluatedConfig: { params: {} },\n      };\n\n      conditionTypes.fetchDynamicValues = dynamicValues;\n      conditionals.fetchDynamicValues =\n        formConfig.conditionals.fetchDynamicValues.condition;\n    }\n\n    // make the evalConfigPaths empty before calling the generateFormEvalFormConfigPaths\n    // this is helpful since we are iterating through the form configs and we do not want to store the value of a\n    // prev form config into another one.\n    evalConfigPaths = [];\n\n    // recursively generate the paths for form cofigs that need evalFormConfig.\n    // and we store them in the evalFormFonfig\n    generateEvalFormConfigPaths(formConfig);\n\n    // we generate a unique array of paths, if the paths are greater than 0,\n    // we generate and add the evaluateFormConfig object to the current formConfig.\n    if (uniq(evalConfigPaths).length > 0) {\n      conditionTypes.visible = false;\n      const evaluateFormConfig: EvaluatedFormConfig = {\n        updateEvaluatedConfig: false,\n        paths: uniq(evalConfigPaths),\n        evaluateFormConfigObject: extractEvalConfigFromFormConfig(\n          formConfig,\n          uniq(evalConfigPaths),\n        ),\n      };\n\n      conditionTypes.evaluateFormConfig = evaluateFormConfig;\n      conditionals.evaluateFormConfig = \"{{true}}\";\n    }\n  }\n\n  // keep the configProperty in the formConfig values.\n  let configPropertyPath;\n\n  if (!!formConfig.configProperty) {\n    configPropertyPath = formConfig.configProperty;\n  }\n\n  let staticDependencyPathList: Set<string> | undefined;\n\n  if (dependencyPaths.length > 0) {\n    staticDependencyPathList = new Set(dependencyPaths);\n  } else {\n    staticDependencyPathList = undefined;\n  }\n\n  // Conditionals are stored in the eval state itself for quick access\n  finalEvalObj[key] = {\n    ...conditionTypes,\n    conditionals,\n    configPropertyPath,\n    staticDependencyPathList,\n  };\n\n  if (\"children\" in formConfig && !!formConfig.children)\n    formConfig.children.forEach((config: FormConfigType) =>\n      generateInitialEvalState(config),\n    );\n\n  if (\"schema\" in formConfig && !!formConfig.schema)\n    formConfig.schema.forEach((config: FormConfigType) =>\n      generateInitialEvalState({ ...config }),\n    );\n};\n\n// The idea here is to recursively go through each of the key value pairs of the current form config\n// then we check if the form config or its children/options/schemas have dynamic values\n// if the children/options/schemas have dynamic values within them, we add the key name of the parent to the evalFormConfigPaths\n// this might sound strange but we add the evaluateFormConfig property to the parent.\n// this is why we pass the parent key into the function and use it to update the evalFormConfig.\nfunction generateEvalFormConfigPaths(\n  formConfig: FormConfigType,\n  parentKey = \"\",\n) {\n  // this stores all the paths for the current form config,\n  // we then use this path to update the evalFormConfig array with the parent\n  const paths: string[] = [];\n  // we never check the conditionals object, or the placeholderText.\n  // we also never check children and schema cause the recursive function that this function is called in already checks the children and schemas (to prevent double recursive checks).\n  // the second placeHolderText is due to a rogue value in the formConfig of one of S3 datasource form config.\n  const configToBeChecked = {\n    ...formConfig,\n    conditionals: undefined,\n    children: undefined,\n    schema: undefined,\n    placeholderText: undefined,\n    placeHolderText: undefined,\n  };\n\n  Object.entries(configToBeChecked).forEach(([key, value]) => {\n    // we check if the current value for the key is a dynamic value, if yes, we push the current key into our paths array.\n    if (!!value) {\n      if (isString(value)) {\n        if (isDynamicValue(value)) {\n          paths.push(key);\n\n          // if parent key is empty, then there is a very good chance it's coming from the root form config.\n          // and in that case we can just set it to it.\n          if (!parentKey) parentKey = key;\n        }\n      }\n\n      // if it's an array, we run it recursively on the array values.\n      if (isArray(value)) {\n        value.forEach((val) => {\n          generateEvalFormConfigPaths(val, key);\n        });\n      }\n\n      // if it is an object, we do the same.\n      if (isTrueObject(value as FormConfigType)) {\n        generateEvalFormConfigPaths(value, key);\n      }\n    }\n  });\n\n  // if the path array is greater than one, we update the evalConfigPaths with parent key.\n  if (paths.length > 0) {\n    evalConfigPaths.push(parentKey);\n  }\n}\n\nfunction evaluateDynamicValuesConfig(\n  actionConfiguration: ActionConfig,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  config: Record<string, any>,\n) {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const evaluatedConfig: Record<string, any> = { ...config };\n  const configArray = Object.entries(config);\n\n  if (configArray.length > 0) {\n    configArray.forEach(([key, value]) => {\n      if (typeof value === \"object\") {\n        evaluatedConfig[key] = evaluateDynamicValuesConfig(\n          actionConfiguration,\n          value,\n        );\n      } else if (typeof value === \"string\" && value.length > 0) {\n        if (isDynamicValue(value)) {\n          let evaluatedValue = \"\";\n\n          try {\n            evaluatedValue = eval(value);\n          } catch (e) {\n            evaluatedValue = \"error\";\n          } finally {\n            evaluatedConfig[key] = evaluatedValue;\n          }\n        }\n      }\n    });\n  }\n\n  return evaluatedConfig;\n}\n\nfunction evaluateFormConfigElements(\n  /* eslint-disable @typescript-eslint/no-unused-vars */\n  actionConfiguration: ActionConfig,\n  config: FormConfigEvalObject,\n  /* eslint-disable @typescript-eslint/no-unused-vars */\n  editorContextType: ActionParentEntityTypeInterface,\n  /* eslint-disable @typescript-eslint/no-unused-vars */\n  datasourceConfiguration?: DatasourceConfiguration,\n) {\n  const paths = objectKeys(config);\n\n  if (paths.length > 0) {\n    paths.forEach((path) => {\n      const { expression } = config[path];\n\n      try {\n        const evaluatedVal = eval(expression);\n\n        config[path].output = evaluatedVal;\n      } catch (e) {}\n    });\n  }\n\n  return config;\n}\n\n// Function to run the eval for the whole form when data changes\nfunction evaluate(\n  actionConfiguration: ActionConfig,\n  currentEvalState: FormEvalOutput,\n  editorContextType: ActionParentEntityTypeInterface,\n  actionDiffPath?: string,\n  hasRouteChanged?: boolean,\n  datasourceConfiguration?: DatasourceConfiguration,\n) {\n  objectKeys(currentEvalState).forEach((key: string) => {\n    try {\n      if (currentEvalState[key].hasOwnProperty(\"conditionals\")) {\n        const conditionBlock = currentEvalState[key].conditionals;\n\n        if (!!conditionBlock) {\n          objectKeys(conditionBlock).forEach((conditionType: string) => {\n            const output = eval(conditionBlock[conditionType]);\n\n            if (conditionType === ConditionType.HIDE) {\n              currentEvalState[key].visible = !output;\n            } else if (conditionType === ConditionType.SHOW) {\n              currentEvalState[key].visible = output;\n            } else if (conditionType === ConditionType.DISABLE) {\n              currentEvalState[key].enabled = !output;\n            } else if (conditionType === ConditionType.ENABLE) {\n              currentEvalState[key].enabled = output;\n            } else if (\n              conditionType === ConditionType.FETCH_DYNAMIC_VALUES &&\n              currentEvalState[key].hasOwnProperty(\"fetchDynamicValues\") &&\n              !!currentEvalState[key].fetchDynamicValues\n            ) {\n              // this boolean value represents if the current action diff path is a dependency to the form config.\n              let isActionDiffADependency = false;\n\n              // If the key in the currentEval state has dynamicDependencyPathList, we check to see if the path of the changed value\n              // exists in the path list, if it does, we evaluate the dynamicValues and fetch the data via API call,\n              // but if the value does not exist in the path list, we prevent the dynamic value from being refetched via API call.\n              // in other words, if the current actionDiffPath is a dependency, then isActionDiffADependency becomes true.\n              if (\n                currentEvalState[key] &&\n                !!currentEvalState[key]?.fetchDynamicValues\n                  ?.dynamicDependencyPathList &&\n                !isEmpty(\n                  currentEvalState[key]?.fetchDynamicValues\n                    ?.dynamicDependencyPathList,\n                ) &&\n                !!actionDiffPath &&\n                currentEvalState[\n                  key\n                ]?.fetchDynamicValues?.dynamicDependencyPathList?.has(\n                  actionDiffPath,\n                )\n              ) {\n                isActionDiffADependency = true;\n              }\n\n              // if the actionDiffPath is a dependency or if the route has changed (navigated to another action/page) of if there's no actionDiffPath at all (when the page is refreshed)\n              // we want to trigger an API call for the dynamic values.\n              if (\n                isActionDiffADependency ||\n                !actionDiffPath ||\n                hasRouteChanged\n              ) {\n                (\n                  currentEvalState[key].fetchDynamicValues as DynamicValues\n                ).allowedToFetch = output;\n                (\n                  currentEvalState[key].fetchDynamicValues as DynamicValues\n                ).isLoading = output;\n                (\n                  currentEvalState[key].fetchDynamicValues as DynamicValues\n                ).evaluatedConfig = evaluateDynamicValuesConfig(\n                  actionConfiguration,\n                  (currentEvalState[key].fetchDynamicValues as DynamicValues)\n                    .config,\n                ) as DynamicValuesConfig;\n              } else {\n                (\n                  currentEvalState[key].fetchDynamicValues as DynamicValues\n                ).allowedToFetch = false;\n                (\n                  currentEvalState[key].fetchDynamicValues as DynamicValues\n                ).isLoading = false;\n              }\n            } else if (\n              conditionType === ConditionType.EVALUATE_FORM_CONFIG &&\n              currentEvalState[key].hasOwnProperty(\"evaluateFormConfig\") &&\n              !!currentEvalState[key].evaluateFormConfig\n            ) {\n              (\n                currentEvalState[key].evaluateFormConfig as EvaluatedFormConfig\n              ).updateEvaluatedConfig = output;\n              currentEvalState[key].visible = output;\n\n              if (output && !!currentEvalState[key].evaluateFormConfig)\n                (\n                  currentEvalState[key]\n                    .evaluateFormConfig as EvaluatedFormConfig\n                ).evaluateFormConfigObject = evaluateFormConfigElements(\n                  actionConfiguration,\n                  (\n                    currentEvalState[key]\n                      .evaluateFormConfig as EvaluatedFormConfig\n                  ).evaluateFormConfigObject,\n                  editorContextType,\n                  datasourceConfiguration,\n                );\n            }\n          });\n        }\n      }\n    } catch (e) {}\n  });\n\n  return currentEvalState;\n}\n\n// Fetches current evaluation and runs a new one based on the new data\nfunction getFormEvaluation(\n  formId: string,\n  actionConfiguration: ActionConfig,\n  currentEvalState: FormEvaluationState,\n  editorContextType: ActionParentEntityTypeInterface,\n  actionDiffPath?: string,\n  hasRouteChanged?: boolean,\n  datasourceConfiguration?: DatasourceConfiguration,\n): FormEvaluationState {\n  // Only change the form evaluation state if the form ID is same or the evaluation state is present\n  if (!!currentEvalState && currentEvalState.hasOwnProperty(formId)) {\n    const currentFormIdEvalState = currentEvalState[formId];\n    // specific conditions to be evaluated\n    let conditionToBeEvaluated = {};\n    // dynamic conditions always need evaluations\n    let dynamicConditionsToBeFetched = {};\n\n    for (const [key, value] of Object.entries(currentFormIdEvalState)) {\n      if (\n        value &&\n        !!value.configPropertyPath &&\n        !!actionDiffPath &&\n        actionDiffPath?.includes(value.configPropertyPath)\n      ) {\n        conditionToBeEvaluated = { ...conditionToBeEvaluated, [key]: value };\n      }\n\n      // static dependency pathlist should be a key of identifiers that point to formControls that are dependent on the result of the current form config value.\n      // it is important to note the difference between staticDependencyPathList and dynamicDependencyPathList is that the former is for formConfigs that don't require API calls.\n      // they are mostly layout based i.e. show/hide, enable/disable\n      if (!!value.staticDependencyPathList && !!actionDiffPath) {\n        value.staticDependencyPathList.forEach(() => {\n          if (value.staticDependencyPathList?.has(actionDiffPath)) {\n            conditionToBeEvaluated = {\n              ...conditionToBeEvaluated,\n              [key]: value,\n            };\n          }\n        });\n      }\n\n      // if there are dynamic values present, add them to the condition to be evaluated.\n      if (value && (!!value.fetchDynamicValues || !!value.evaluateFormConfig)) {\n        dynamicConditionsToBeFetched = {\n          ...dynamicConditionsToBeFetched,\n          [key]: value,\n        };\n      }\n    }\n\n    // if no condition is to be evaluated or if the currently changing action diff path is the command path\n    // then we run evaluations on the whole form.\n    if (\n      isEmpty(conditionToBeEvaluated) ||\n      actionDiffPath === FormDataPaths.COMMAND\n    ) {\n      conditionToBeEvaluated = evaluate(\n        actionConfiguration,\n        currentEvalState[formId],\n        editorContextType,\n        actionDiffPath,\n        hasRouteChanged,\n        datasourceConfiguration,\n      );\n    } else {\n      conditionToBeEvaluated = {\n        ...conditionToBeEvaluated,\n        ...dynamicConditionsToBeFetched,\n      };\n      conditionToBeEvaluated = evaluate(\n        actionConfiguration,\n        conditionToBeEvaluated,\n        editorContextType,\n        actionDiffPath,\n        hasRouteChanged,\n        datasourceConfiguration,\n      );\n    }\n\n    currentEvalState[formId] = {\n      ...currentEvalState[formId],\n      ...conditionToBeEvaluated,\n    };\n  }\n\n  return currentEvalState;\n}\n\n// Filter function to assign a function to the Action dispatched\nexport function setFormEvaluationSaga(\n  type: string,\n  payload: FormEvalActionPayload,\n  currentEvalState: FormEvaluationState,\n) {\n  if (type === ReduxActionTypes.INIT_FORM_EVALUATION) {\n    finalEvalObj = {};\n\n    // Config is extracted from the editor json first\n    if (\n      \"editorConfig\" in payload &&\n      !!payload.editorConfig &&\n      payload.editorConfig.length > 0\n    ) {\n      payload.editorConfig.forEach((config: FormConfigType) => {\n        generateInitialEvalState(config);\n      });\n    }\n\n    // Then the form config is extracted from the settings json\n    if (\n      \"settingConfig\" in payload &&\n      !!payload.settingConfig &&\n      payload.settingConfig.length > 0\n    ) {\n      payload.settingConfig.forEach((config: FormConfigType) => {\n        generateInitialEvalState(config);\n      });\n    }\n\n    // if the evaluations are empty, then the form is not valid, don't mutate the state\n    if (isEmpty(finalEvalObj)) {\n      return currentEvalState;\n    }\n\n    // This is the initial evaluation state, evaluations can now be run on top of this\n    return { [payload.formId]: finalEvalObj };\n  } else {\n    const {\n      actionConfiguration,\n      actionDiffPath,\n      datasourceConfiguration,\n      editorContextType,\n      formId,\n      hasRouteChanged,\n    } = payload;\n\n    // In case the formData is not ready or the form is not of type UQI, return empty state\n    if (!actionConfiguration) {\n      return currentEvalState;\n    } else {\n      return getFormEvaluation(\n        formId,\n        actionConfiguration,\n        currentEvalState,\n        editorContextType || ActionParentEntityType.PAGE,\n        actionDiffPath,\n        hasRouteChanged,\n        datasourceConfiguration,\n      );\n    }\n  }\n}\n","export const DATA_BIND_REGEX = /{{([\\s\\S]*?)}}/;\nexport const DATA_BIND_REGEX_GLOBAL = /{{([\\s\\S]*?)}}/g;\nexport const AUTOCOMPLETE_MATCH_REGEX = /{{\\s*.*?\\s*}}/g;\nexport const QUOTED_BINDING_REGEX = /[\"']({{[\\s\\S]*?}})[\"']/g;\n","// 🚧 NOTE: this file exists only for the worker thread, as the worker thread needs to pass\n// the full Lodash library around. *Do not* import it in the main thread code, as that will\n// result in bundling the full Lodash. If you’re trying to pass a Lodash reference into some\n// function in the main thread, consider if you can instead:\n//\n// - import and call Lodash directly:\n//\n//   Before:\n//     // a.js\n//     export function mapArray(_) { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     import _ from 'lodash';\n//     mapArray(_);\n//\n//   After:\n//     // a.js\n//     import _ from 'lodash';\n//     export function mapArray() { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     mapArray();\n//\n// - pass only the function you need about:\n//\n//   Before:\n//     // a.js\n//     export function mapArray(_) { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     import _ from 'lodash';\n//     mapArray(_);\n//\n//   After:\n//     // a.js\n//     export function mapArray(_) { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     import _ from 'lodash';\n//     mapArray({ map: _.map });\nif (\n  typeof window !== \"undefined\" &&\n  // Jest mocks the `window` object when running worker tests\n  process.env.NODE_ENV !== \"test\"\n) {\n  throw new Error(\"lodash-wrapper.js must only be used in a worker thread\");\n}\n\n/////////////////////////////////////////////////////////////////////////\n//\n// We use babel-plugin-lodash to only import the lodash functions we use.\n// Unfortunately, the plugin doesn’t work with the following pattern:\n//   import _ from 'lodash';\n//   const something = _;\n// When it encounters code like above, it will replace _ with `undefined`,\n// which will break the app (https://github.com/lodash/babel-plugin-lodash/issues/235).\n//\n// Given that we *need* to use the full lodash in ./resetJSLibraries.js,\n// we use this workaround where we’re importing Lodash using CommonJS require().\n// It works because babel-plugin-lodash doesn’t support CommonJS require().\nmodule.exports = require(\"lodash\");\n","import {\n  getEntityNameAndPropertyPath,\n  isWidget,\n  overrideWidgetProperties,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport { evalTreeWithChanges } from \"./evalTreeWithChanges\";\nimport { dataTreeEvaluator } from \"./handlers/evalTree\";\nimport { get, set } from \"lodash\";\nimport { validate } from \"./validations\";\nimport type {\n  DataTreeEntityConfig,\n  WidgetEntity,\n} from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport { getFnWithGuards, isAsyncGuard } from \"./fns/utils/fnGuard\";\nimport { shouldAddSetter } from \"./evaluate\";\nimport { EVAL_WORKER_SYNC_ACTION } from \"ee/workers/Evaluation/evalWorkerActions\";\n\nclass Setters {\n  /** stores the setter method accessor as key and true as value\n   *\n   * example - ```{ \"Table1.setVisibility\": true, \"Table1.setData\": true }```\n   */\n  private setterMethodLookup: Record<string, true> = {};\n  /** stores the setter property accessor as key and setter method name as value\n   *\n   * example - ```{ \"Table1.tableData\": \"Table1.setData\" }```\n   */\n  private setterAccessorMap: Record<string, string> = {};\n\n  private async applySetterMethod(\n    path: string,\n    value: unknown,\n    setterMethodName: string,\n  ) {\n    const { entityName, propertyPath } = getEntityNameAndPropertyPath(path);\n\n    if (!dataTreeEvaluator) return;\n\n    const evalTree = dataTreeEvaluator.getEvalTree();\n    const configTree = dataTreeEvaluator.getConfigTree();\n\n    const entity = evalTree[entityName];\n    const entityConfig = configTree[entityName];\n\n    const updatedProperties: string[][] = [];\n    const overriddenProperties: string[] = [];\n    const evalMetaUpdates: EvalMetaUpdates = [];\n\n    let parsedValue = value;\n\n    if (value === undefined) {\n      const error = new Error(\n        `The value passed to ${entityName}.${setterMethodName}() evaluates to undefined.`,\n      );\n\n      error.name = entityName + \".\" + setterMethodName + \" failed\";\n      throw error;\n    }\n\n    const { validationPaths } = entityConfig;\n\n    if (validationPaths) {\n      const validationConfig = validationPaths[propertyPath] || {};\n\n      const config = {\n        ...validationConfig,\n        params: { ...(validationConfig.params || {}) },\n      };\n\n      config.params.strict = true;\n\n      const { isValid, messages, parsed } = validate(\n        config,\n        value,\n        entity as Record<string, unknown>,\n        propertyPath,\n      );\n\n      parsedValue = parsed;\n\n      if (!isValid) {\n        const message = messages && messages[0] ? messages[0].message : \"\";\n        const error = new Error(\n          `${entityName + \".\" + setterMethodName}: ${message}`,\n        );\n\n        error.name = entityName + \".\" + setterMethodName + \" failed\";\n        throw error;\n      }\n    }\n\n    if (isWidget(entity)) {\n      overrideWidgetProperties({\n        entity: entity as WidgetEntity,\n        propertyPath,\n        value: parsedValue,\n        currentTree: evalTree,\n        configTree,\n        evalMetaUpdates,\n        fullPropertyPath: path,\n        isNewWidget: false,\n        shouldUpdateGlobalContext: true,\n        overriddenProperties,\n      });\n\n      overriddenProperties.forEach((propPath) => {\n        updatedProperties.push([entityName, propPath]);\n      });\n    }\n\n    set(evalTree, path, parsedValue);\n    set(self, path, parsedValue);\n\n    /**\n     * Making the update to dataTree async as there could be queue microtask updates that need to execute before this update.\n     * Issue:- https://github.com/appsmithorg/appsmith/issues/25364\n     */\n    return new Promise((resolve) => {\n      resolve(parsedValue);\n    }).then((res) => {\n      updatedProperties.push([entityName, propertyPath]);\n\n      evalTreeWithChanges({\n        data: {\n          updatedValuePaths: updatedProperties,\n          metaUpdates: evalMetaUpdates,\n        },\n        method: EVAL_WORKER_SYNC_ACTION.EVAL_TREE_WITH_CHANGES,\n        webworkerTelemetry: {},\n      });\n\n      return res;\n    });\n  }\n  /** Generates a new setter method */\n  private createSetter(\n    path: string,\n    setterMethodName: string,\n    entityName: string,\n  ) {\n    /** register the setter method in the lookup */\n    set(this.setterMethodLookup, [entityName, setterMethodName], true);\n\n    const fn = async (value: unknown) => {\n      if (!dataTreeEvaluator) return;\n\n      return this.applySetterMethod(path, value, setterMethodName);\n    };\n\n    return getFnWithGuards(fn, setterMethodName, [isAsyncGuard]);\n  }\n\n  clear() {\n    this.setterMethodLookup = {};\n  }\n\n  has(entityName: string, propertyName: string) {\n    return get(this.setterMethodLookup, [entityName, propertyName], false);\n  }\n\n  getMap() {\n    return this.setterMethodLookup;\n  }\n\n  getSetterAccessorMap() {\n    return this.setterAccessorMap;\n  }\n\n  getEntitySettersFromConfig(\n    entityConfig: DataTreeEntityConfig,\n    entityName: string,\n    entity: DataTreeEntity,\n  ) {\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const setterMethodMap: Record<string, any> = {};\n\n    if (!entityConfig) return setterMethodMap;\n\n    if (entityConfig.__setters) {\n      for (const setterMethodName of Object.keys(entityConfig.__setters)) {\n        const pathToSet = entityConfig.__setters[setterMethodName].path;\n\n        if (!shouldAddSetter(entityConfig.__setters[setterMethodName], entity))\n          continue;\n\n        this.setterAccessorMap[pathToSet] = `${entityName}.${setterMethodName}`;\n\n        setterMethodMap[setterMethodName] = this.createSetter(\n          pathToSet,\n          setterMethodName,\n          entityName,\n        );\n      }\n    }\n\n    return setterMethodMap;\n  }\n\n  init(configTree: ConfigTree, dataTree: DataTree) {\n    const configTreeEntries = Object.entries(configTree);\n\n    for (const [entityName, entityConfig] of configTreeEntries) {\n      const entity = dataTree[entityName];\n\n      this.getEntitySettersFromConfig(entityConfig, entityName, entity);\n    }\n  }\n}\n\nconst setters = new Setters();\n\nexport default setters;\n","import { dataTreeEvaluator } from \"./handlers/evalTree\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport { makeEntityConfigsAsObjProperties } from \"ee/workers/Evaluation/dataTreeUtils\";\nimport type {\n  EvalTreeResponseData,\n  EvalWorkerSyncRequest,\n  UpdateTreeResponse,\n} from \"./types\";\nimport { MessageType, sendMessage } from \"utils/MessageUtil\";\nimport { MAIN_THREAD_ACTION } from \"ee/workers/Evaluation/evalWorkerActions\";\nimport type { UpdateDataTreeMessageData } from \"sagas/EvalWorkerActionSagas\";\nimport {\n  generateOptimisedUpdatesAndSetPrevState,\n  getNewDataTreeUpdates,\n  uniqueOrderUpdatePaths,\n} from \"./helpers\";\nimport type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type DataTreeEvaluator from \"workers/common/DataTreeEvaluator\";\n\nconst getDefaultEvalResponse = (): EvalTreeResponseData => ({\n  updates: \"[]\",\n  dependencies: {},\n  errors: [],\n  evalMetaUpdates: [],\n  evaluationOrder: [],\n  jsUpdates: {},\n  logs: [],\n  unEvalUpdates: [],\n  isCreateFirstTree: false,\n  staleMetaIds: [],\n  removedPaths: [],\n  isNewWidgetAdded: false,\n  undefinedEvalValuesMap: {},\n  jsVarsCreatedEvent: [],\n});\n\nexport function evalTreeWithChanges(\n  request: EvalWorkerSyncRequest<{\n    metaUpdates?: EvalMetaUpdates;\n    updatedValuePaths: string[][];\n  }>,\n) {\n  const { data } = request;\n  const { metaUpdates = [], updatedValuePaths } = data;\n\n  const pathsToSkipFromEval = updatedValuePaths.map((path) => path.join(\".\"));\n\n  let setupUpdateTreeResponse = {} as UpdateTreeResponse;\n\n  if (dataTreeEvaluator) {\n    setupUpdateTreeResponse = dataTreeEvaluator.setupUpdateTreeWithDifferences(\n      updatedValuePaths,\n      pathsToSkipFromEval,\n    );\n  }\n\n  evaluateAndPushResponse(\n    dataTreeEvaluator,\n    setupUpdateTreeResponse,\n    metaUpdates,\n    pathsToSkipFromEval,\n  );\n}\n\nexport const getAffectedNodesInTheDataTree = (\n  unEvalUpdates: DataTreeDiff[],\n  evalOrder: string[],\n) => {\n  const allUnevalUpdates = unEvalUpdates.map(\n    (update) => update.payload.propertyPath,\n  );\n\n  // merge unevalUpdate paths and evalOrder paths\n  return uniqueOrderUpdatePaths([...allUnevalUpdates, ...evalOrder]);\n};\n\nexport const evaluateAndPushResponse = (\n  dataTreeEvaluator: DataTreeEvaluator | undefined,\n  setupUpdateTreeResponse: UpdateTreeResponse,\n  metaUpdates: EvalMetaUpdates,\n  additionalPathsAddedAsUpdates: string[],\n) => {\n  const response = evaluateAndGenerateResponse(\n    dataTreeEvaluator,\n    setupUpdateTreeResponse,\n    metaUpdates,\n    additionalPathsAddedAsUpdates,\n  );\n\n  return pushResponseToMainThread(response);\n};\n\nexport const evaluateAndGenerateResponse = (\n  dataTreeEvaluator: DataTreeEvaluator | undefined,\n  setupUpdateTreeResponse: UpdateTreeResponse,\n  metaUpdates: EvalMetaUpdates,\n  additionalPathsAddedAsUpdates: string[],\n): UpdateDataTreeMessageData => {\n  // generate default response first and later add updates to it\n  const defaultResponse = getDefaultEvalResponse();\n\n  if (!dataTreeEvaluator) {\n    const updates = generateOptimisedUpdatesAndSetPrevState(\n      {},\n      dataTreeEvaluator,\n      [],\n    );\n\n    defaultResponse.updates = updates;\n    defaultResponse.evalMetaUpdates = [...(metaUpdates || [])];\n\n    return {\n      workerResponse: defaultResponse,\n    };\n  }\n\n  const { evalOrder, jsUpdates, unEvalUpdates } = setupUpdateTreeResponse;\n\n  defaultResponse.evaluationOrder = evalOrder;\n  defaultResponse.unEvalUpdates = unEvalUpdates;\n  defaultResponse.jsUpdates = jsUpdates;\n\n  const updateResponse = dataTreeEvaluator.evalAndValidateSubTree(\n    evalOrder,\n    dataTreeEvaluator.oldConfigTree,\n    unEvalUpdates,\n  );\n\n  const dataTree = makeEntityConfigsAsObjProperties(\n    dataTreeEvaluator.evalTree,\n    {\n      evalProps: dataTreeEvaluator.evalProps,\n    },\n  );\n\n  /** Make sure evalMetaUpdates is sanitized to prevent postMessage failure */\n  defaultResponse.evalMetaUpdates = JSON.parse(\n    JSON.stringify([...(metaUpdates || []), ...updateResponse.evalMetaUpdates]),\n  );\n\n  defaultResponse.staleMetaIds = updateResponse.staleMetaIds;\n  defaultResponse.dependencies = dataTreeEvaluator.inverseDependencies;\n\n  // when additional paths are required to be added as updates, we extract the updates from the data tree using these paths.\n  const additionalUpdates = getNewDataTreeUpdates(\n    additionalPathsAddedAsUpdates,\n    dataTree,\n  );\n  // the affected paths is a combination of the eval order and the uneval updates\n  // we use this collection to limit the diff between the old and new data tree\n  const affectedNodePaths = getAffectedNodesInTheDataTree(\n    unEvalUpdates,\n    evalOrder,\n  );\n\n  defaultResponse.updates = generateOptimisedUpdatesAndSetPrevState(\n    dataTree,\n    dataTreeEvaluator,\n    affectedNodePaths,\n    additionalUpdates,\n  );\n  dataTreeEvaluator.undefinedEvalValuesMap =\n    dataTreeEvaluator.undefinedEvalValuesMap || {};\n\n  return {\n    workerResponse: defaultResponse,\n  };\n};\n\nexport const pushResponseToMainThread = (data: UpdateDataTreeMessageData) => {\n  sendMessage.call(self, {\n    messageType: MessageType.DEFAULT,\n    body: {\n      data,\n      method: MAIN_THREAD_ACTION.UPDATE_DATATREE,\n    },\n  });\n};\n","import { parseExpressionAt, type Node } from \"acorn\";\nimport { simple } from \"acorn-walk\";\nimport type {\n  IdentifierNode,\n  LiteralNode,\n  NodeWithLocation,\n  PropertyNode,\n} from \"../index\";\nimport {\n  getAST,\n  isExportDefaultDeclarationNode,\n  isObjectExpression,\n  isTypeOfFunction,\n} from \"../index\";\nimport { generate } from \"astring\";\nimport type { functionParam } from \"../index\";\nimport { getFunctionalParamsFromNode, isPropertyAFunctionNode } from \"../index\";\nimport { ECMA_VERSION, SourceType } from \"../../index\";\nimport escodegen, { attachComments } from \"escodegen\";\nimport { extractContentByPosition } from \"../utils\";\n\nconst jsObjectVariableName =\n  \"____INTERNAL_JS_OBJECT_NAME_USED_FOR_PARSING_____\";\n\nexport const jsObjectDeclaration = `var ${jsObjectVariableName} =`;\n\nexport interface JSPropertyPosition {\n  startLine: number;\n  startColumn: number;\n  endLine: number;\n  endColumn: number;\n  keyStartLine: number;\n  keyEndLine: number;\n  keyStartColumn: number;\n  keyEndColumn: number;\n}\n\ninterface BaseJSProperty {\n  key: string;\n  value: string;\n  type: string;\n  position: Partial<JSPropertyPosition>;\n  rawContent: string;\n}\n\nexport type JSFunctionProperty = BaseJSProperty & {\n  arguments: functionParam[];\n  // If function uses the \"async\" keyword\n  isMarkedAsync: boolean;\n};\nexport type JSVarProperty = BaseJSProperty;\n\nexport type TParsedJSProperty = JSVarProperty | JSFunctionProperty;\n\ninterface Property extends PropertyNode {\n  key: IdentifierNode;\n}\n\nexport const isJSFunctionProperty = (\n  t: TParsedJSProperty,\n): t is JSFunctionProperty => {\n  return isTypeOfFunction(t.type);\n};\n\nexport const parseJSObject = (code: string) => {\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n  const result: TParsedJSProperty[] = [];\n\n  try {\n    const comments: any = [];\n    const token: any = [];\n\n    ast = getAST(code, {\n      sourceType: SourceType.module,\n      onComment: comments,\n      onToken: token,\n      ranges: true,\n      locations: true,\n    });\n    attachComments(ast, comments, token);\n  } catch (e) {\n    return { parsedObject: result, success: false };\n  }\n\n  const parsedObjectProperties = new Set<TParsedJSProperty>();\n  let JSObjectProperties: NodeWithLocation<PropertyNode>[] = [];\n\n  simple(ast, {\n    ExportDefaultDeclaration(node: Node) {\n      if (\n        !isExportDefaultDeclarationNode(node) ||\n        !isObjectExpression(node.declaration)\n      )\n        return;\n\n      JSObjectProperties = node.declaration\n        .properties as NodeWithLocation<PropertyNode>[];\n    },\n  });\n\n  JSObjectProperties.forEach((node) => {\n    const propertyKey = node.key as NodeWithLocation<\n      LiteralNode | IdentifierNode\n    >;\n    let property: TParsedJSProperty = {\n      key: generate(node.key),\n      value: generate(node.value),\n      rawContent: extractContentByPosition(code, {\n        from: {\n          line: node.loc.start.line - 1,\n          ch: node.loc.start.column,\n        },\n        to: {\n          line: node.loc.end.line - 1,\n          ch: node.loc.end.column - 1,\n        },\n      }),\n      type: node.value.type,\n      position: {\n        startLine: node.loc.start.line,\n        startColumn: node.loc.start.column,\n        endLine: node.loc.end.line,\n        endColumn: node.loc.end.column,\n        keyStartLine: propertyKey.loc.start.line,\n        keyEndLine: propertyKey.loc.end.line,\n        keyStartColumn: propertyKey.loc.start.column,\n        keyEndColumn: propertyKey.loc.end.column,\n      },\n    };\n\n    if (isPropertyAFunctionNode(node.value)) {\n      const params = getFunctionalParamsFromNode(node.value, true, code);\n\n      property = {\n        ...property,\n        arguments: [...params],\n        isMarkedAsync: node.value.async,\n      };\n    }\n\n    parsedObjectProperties.add(property);\n  });\n\n  return { parsedObject: [...parsedObjectProperties], success: true };\n};\n\nexport const addPropertiesToJSObjectCode = (\n  code: string,\n  obj: Record<string, string>,\n) => {\n  try {\n    const ast = getAST(code, { sourceType: \"module\" });\n\n    simple(ast, {\n      ExportDefaultDeclaration(node: any) {\n        const properties: Property[] = node?.declaration?.properties;\n\n        Object.entries(obj).forEach(([key, value]) => {\n          // Check if a property with the same name already exists\n          const existingPropertyIndex = properties.findIndex(\n            (property) => property.key.name === key,\n          );\n\n          const astValue = parseExpressionAt(value, 0, {\n            ecmaVersion: ECMA_VERSION,\n          });\n\n          // Create a new property\n          const newProperty = {\n            type: \"Property\",\n            key: { type: \"Identifier\", name: key },\n            value: astValue,\n            kind: \"init\",\n            method: false,\n            shorthand: false,\n            computed: false,\n          } as unknown as Property;\n\n          if (existingPropertyIndex >= 0) {\n            // Replace the existing property\n            properties[existingPropertyIndex] = newProperty;\n          } else {\n            // Add the new property\n            properties.push(newProperty);\n          }\n        });\n      },\n    });\n\n    return escodegen.generate(ast);\n  } catch (e) {\n    return code;\n  }\n};\n","// This is a hard-coded list of DOM APIs that linkedom provides. We’re hardcoding it instead of deriving it\n// from documentMock because domApiNames are used in the main thread, and deriving them from linkedom\n// will keep linkedom in the main thread’s bundle.\nconst DOM_API_NAMES = [\n  \"Attr\",\n  \"CharacterData\",\n  \"Comment\",\n  \"CustomEvent\",\n  \"DOMParser\",\n  \"Document\",\n  \"DocumentFragment\",\n  \"DocumentType\",\n  \"Element\",\n  \"Event\",\n  \"EventTarget\",\n  \"Facades\",\n  \"HTMLAnchorElement\",\n  \"HTMLAreaElement\",\n  \"HTMLAudioElement\",\n  \"HTMLBRElement\",\n  \"HTMLBaseElement\",\n  \"HTMLBodyElement\",\n  \"HTMLButtonElement\",\n  \"HTMLCanvasElement\",\n  \"HTMLClasses\",\n  \"HTMLDListElement\",\n  \"HTMLDataElement\",\n  \"HTMLDataListElement\",\n  \"HTMLDetailsElement\",\n  \"HTMLDirectoryElement\",\n  \"HTMLDivElement\",\n  \"HTMLElement\",\n  \"HTMLEmbedElement\",\n  \"HTMLFieldSetElement\",\n  \"HTMLFontElement\",\n  \"HTMLFormElement\",\n  \"HTMLFrameElement\",\n  \"HTMLFrameSetElement\",\n  \"HTMLHRElement\",\n  \"HTMLHeadElement\",\n  \"HTMLHeadingElement\",\n  \"HTMLHtmlElement\",\n  \"HTMLIFrameElement\",\n  \"HTMLImageElement\",\n  \"HTMLInputElement\",\n  \"HTMLLIElement\",\n  \"HTMLLabelElement\",\n  \"HTMLLegendElement\",\n  \"HTMLLinkElement\",\n  \"HTMLMapElement\",\n  \"HTMLMarqueeElement\",\n  \"HTMLMediaElement\",\n  \"HTMLMenuElement\",\n  \"HTMLMetaElement\",\n  \"HTMLMeterElement\",\n  \"HTMLModElement\",\n  \"HTMLOListElement\",\n  \"HTMLObjectElement\",\n  \"HTMLOptGroupElement\",\n  \"HTMLOptionElement\",\n  \"HTMLOutputElement\",\n  \"HTMLParagraphElement\",\n  \"HTMLParamElement\",\n  \"HTMLPictureElement\",\n  \"HTMLPreElement\",\n  \"HTMLProgressElement\",\n  \"HTMLQuoteElement\",\n  \"HTMLScriptElement\",\n  \"HTMLSelectElement\",\n  \"HTMLSlotElement\",\n  \"HTMLSourceElement\",\n  \"HTMLSpanElement\",\n  \"HTMLStyleElement\",\n  \"HTMLTableCaptionElement\",\n  \"HTMLTableCellElement\",\n  \"HTMLTableElement\",\n  \"HTMLTableRowElement\",\n  \"HTMLTemplateElement\",\n  \"HTMLTextAreaElement\",\n  \"HTMLTimeElement\",\n  \"HTMLTitleElement\",\n  \"HTMLTrackElement\",\n  \"HTMLUListElement\",\n  \"HTMLUnknownElement\",\n  \"HTMLVideoElement\",\n  \"InputEvent\",\n  \"Node\",\n  \"NodeFilter\",\n  \"NodeList\",\n  \"SVGElement\",\n  \"ShadowRoot\",\n  \"Text\",\n  \"illegalConstructor\",\n  \"parseHTML\",\n  \"parseJSON\",\n  \"toJSON\",\n] as const;\n\nconst DOM_APIS = DOM_API_NAMES.reduce(\n  (acc, key) => {\n    acc[key] = true;\n\n    return acc;\n  },\n  {} as Record<string, true | undefined>,\n);\n\nexport default DOM_APIS;\n","import type { ReduxAction } from \"actions/ReduxActionTypes\";\nimport type LOG_TYPE from \"./logtype\";\nimport type { PropertyEvaluationErrorType } from \"utils/DynamicBindingUtils\";\nimport type { PluginType } from \"entities/Plugin\";\nimport type { HTTP_METHOD } from \"PluginActionEditor/constants/CommonApiConstants\";\nimport type {\n  ENTITY_TYPE,\n  PLATFORM_ERROR,\n} from \"ee/entities/AppsmithConsole/utils\";\n\nexport type Methods =\n  | \"log\"\n  | \"debug\"\n  | \"info\"\n  | \"warn\"\n  | \"error\"\n  | \"table\"\n  | \"clear\"\n  | \"time\"\n  | \"timeEnd\"\n  | \"count\"\n  | \"assert\";\n\nexport interface LogObject {\n  method: Methods | \"result\";\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  data: any[];\n  timestamp: string;\n  id: string;\n  severity: Severity;\n  source: SourceEntity;\n}\n\nexport type ErrorType = PropertyEvaluationErrorType | PLATFORM_ERROR;\n\nexport enum Severity {\n  // Everything, irrespective of what the user should see or not\n  // DEBUG = \"debug\",\n  // Something the dev user should probably know about\n  INFO = \"info\",\n  // Doesn't break the app, but can cause slowdowns / ux issues/ unexpected behaviour\n  WARNING = \"warning\",\n  // Can cause an error in some cases/ single widget, app will work in other cases\n  ERROR = \"error\",\n  // Makes the app unusable, can't progress without fixing this.\n  // CRITICAL = \"critical\",\n}\n\nexport interface UserAction {\n  // Label is used to display the\n  label: string;\n  // As there can be multiple errors of the same base type at the same time\n  // and we need to be able to tell the difference,\n  // these action types should have a dynamic `id` associated with them\n  // or we should use JS callback functions instead\n  reduxAction: ReduxAction<unknown>;\n}\n\nexport interface SourceEntity {\n  type: ENTITY_TYPE;\n  // Widget or action name\n  name: string;\n  // Id of the widget or action\n  id: string;\n  // property path of the child\n  propertyPath?: string;\n  // plugin type of the action or type of widget\n  pluginType?: PluginType | string;\n  // http method of the api. (Only for api actions)\n  httpMethod?: HTTP_METHOD;\n}\n\nexport enum LOG_CATEGORY {\n  USER_GENERATED = \"USER_GENERATED\",\n  PLATFORM_GENERATED = \"PLATFORM_GENERATED\",\n}\n\nexport interface LogActionPayload {\n  // Log id, used for updating or deleting\n  id?: string;\n  // icon id, used in finding appropriate icons.\n  iconId?: string;\n  // What is the log about. Is it a datasource update, widget update, eval error etc.\n  logType?: LOG_TYPE;\n  // This is the preview of the log that the user sees.\n  text: string;\n  // The environment in which the log was generated.\n  environmentName?: string;\n  // Number of times this log has been repeated\n  occurrenceCount?: number;\n  // Deconstructed data of the log, this includes the whole nested objects/arrays/strings etc.\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  logData?: any[];\n  // messages associated with this event\n  messages?: Array<Message>;\n  // Time taken for the event to complete\n  timeTaken?: string;\n  // \"where\" source entity and propertyPsath.\n  source?: SourceEntity;\n  // Snapshot KV pair of scope variables or state associated with this event.\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  state?: Record<string, any>;\n  // Any other data required for analytics\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  analytics?: Record<string, any>;\n  // plugin error details if any (only for plugin errors).\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  pluginErrorDetails?: any;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  meta?: Record<string, any>;\n}\n\nexport interface Message {\n  // More contextual message than `text`\n  message: Error;\n  type?: ErrorType;\n  subType?: string;\n  lineNumber?: number;\n  character?: number;\n  // The section of code being referred to\n  // codeSegment?: string;\n}\n\nexport interface Log extends LogActionPayload {\n  severity: Severity;\n  // Is the log system generated or user generated\n  category: LOG_CATEGORY;\n  // \"when\" did this event happen\n  timestamp: string;\n  // expanded state of the log.\n  isExpanded: boolean;\n}\n\n/**\n * Example:\n * \"Api timed out\"\n * {\n *   type: ActionError.EXECUTION_TIMEOUT,\n *   timeoutMs: 10000,\n *   severity: Severity.ERROR,\n *   message: \"Action execution timedout after 10 seconds\",\n *   source: {\n *     type: ENTITY_TYPE.ACTION,\n *     name: \"Api1\",\n *     id: \"a12345\",\n *     propertyPath: \"run\",\n *   },\n *   timestamp: new Date(),\n *   state: {},\n *   userActions: [\n *     {\n *       label: \"Increase timeout by 5 seconds\",\n *       reduxAction: {\n *         type: \"ACTION_INCREASE_TIMEOUT\",\n *         payload: { actionId: \"abcdef\", value: 5000 },\n *       },\n *     },\n *   ]\n * }\n */\n","import type { ErrorActionPayload } from \"sagas/ErrorSagas\";\nimport type { ActionResponse } from \"api/ActionAPI\";\nimport { PluginType } from \"entities/Plugin\";\nimport queryActionSettingsConfig from \"constants/AppsmithActionConstants/formConfig/QuerySettingsConfig\";\nimport apiActionSettingsConfig from \"constants/AppsmithActionConstants/formConfig/ApiSettingsConfig\";\nimport apiActionEditorConfig from \"constants/AppsmithActionConstants/formConfig/ApiEditorConfigs\";\nimport saasActionSettingsConfig from \"constants/AppsmithActionConstants/formConfig/GoogleSheetsSettingsConfig\";\nimport apiActionDependencyConfig from \"constants/AppsmithActionConstants/formConfig/ApiDependencyConfigs\";\nimport apiActionDatasourceFormButtonConfig from \"constants/AppsmithActionConstants/formConfig/ApiDatasourceFormsButtonConfig\";\nimport type { EntityTypeValue } from \"ee/entities/DataTree/types\";\n\nexport interface ExecuteActionPayloadEvent {\n  type: EventType;\n  callback?: (result: ExecutionResult) => void;\n}\n\nexport interface ExecutionResult {\n  success: boolean;\n}\n\nexport interface TriggerSource {\n  id: string;\n  name: string;\n  entityType?: EntityTypeValue;\n  collectionId?: string;\n  isJSAction?: boolean;\n  actionId?: string;\n}\n\nexport enum TriggerKind {\n  EVENT_EXECUTION = \"EVENT_EXECUTION\", // Eg. Button onClick\n  JS_FUNCTION_EXECUTION = \"JS_FUNCTION_EXECUTION\", // Executing js function from jsObject page\n}\n\nexport interface ExecuteTriggerPayload {\n  dynamicString: string;\n  event: ExecuteActionPayloadEvent;\n  callbackData?: Array<unknown>;\n  triggerPropertyName?: string;\n  source?: TriggerSource;\n  widgetId?: string;\n  globalContext?: Record<string, unknown>;\n}\n\nexport type ContentType =\n  | \"application/json\"\n  | \"application/x-www-form-urlencoded\";\n\nexport interface APIHeaders {\n  \"Content-Type\": ContentType;\n  Accept?: string;\n}\n\nexport interface APIRequest {\n  requestId?: string;\n}\n\nexport enum EventType {\n  ON_RESET = \"ON_RESET\",\n  ON_PAGE_LOAD = \"ON_PAGE_LOAD\",\n  ON_PREV_PAGE = \"ON_PREV_PAGE\",\n  ON_NEXT_PAGE = \"ON_NEXT_PAGE\",\n  ON_PAGE_SIZE_CHANGE = \"ON_PAGE_SIZE_CHANGE\",\n  ON_ERROR = \"ON_ERROR\",\n  ON_SUCCESS = \"ON_SUCCESS\",\n  ON_ROW_SELECTED = \"ON_ROW_SELECTED\",\n  ON_SEARCH = \"ON_SEARCH\",\n  ON_CLICK = \"ON_CLICK\",\n  ON_DATA_POINT_CLICK = \"ON_DATA_POINT_CLICK\",\n  ON_FILES_SELECTED = \"ON_FILES_SELECTED\",\n  ON_HOVER = \"ON_HOVER\",\n  ON_TOGGLE = \"ON_TOGGLE\",\n  ON_LOAD = \"ON_LOAD\",\n  ON_MODAL_CLOSE = \"ON_MODAL_CLOSE\",\n  ON_MODAL_SUBMIT = \"ON_MODAL_SUBMIT\",\n  ON_TEXT_CHANGE = \"ON_TEXT_CHANGE\",\n  ON_SUBMIT = \"ON_SUBMIT\",\n  ON_CHECK_CHANGE = \"ON_CHECK_CHANGE\",\n  ON_SWITCH_CHANGE = \"ON_SWITCH_CHANGE\",\n  ON_SELECT = \"ON_SELECT\",\n  ON_DATE_SELECTED = \"ON_DATE_SELECTED\",\n  ON_DATE_RANGE_SELECTED = \"ON_DATE_RANGE_SELECTED\",\n  ON_DROPDOWN_OPEN = \"ON_DROPDOWN_OPEN\",\n  ON_DROPDOWN_CLOSE = \"ON_DROPDOWN_CLOSE\",\n  ON_OPTION_CHANGE = \"ON_OPTION_CHANGE\",\n  ON_FILTER_CHANGE = \"ON_FILTER_CHANGE\",\n  ON_FILTER_UPDATE = \"ON_FILTER_UPDATE\",\n  ON_MARKER_CLICK = \"ON_MARKER_CLICK\",\n  ON_CREATE_MARKER = \"ON_CREATE_MARKER\",\n  ON_TAB_CHANGE = \"ON_TAB_CHANGE\",\n  ON_VIDEO_START = \"ON_VIDEO_START\",\n  ON_VIDEO_END = \"ON_VIDEO_END\",\n  ON_VIDEO_PLAY = \"ON_VIDEO_PLAY\",\n  ON_VIDEO_PAUSE = \"ON_VIDEO_PAUSE\",\n  ON_AUDIO_START = \"ON_AUDIO_START\",\n  ON_AUDIO_END = \"ON_AUDIO_END\",\n  ON_AUDIO_PLAY = \"ON_AUDIO_PLAY\",\n  ON_AUDIO_PAUSE = \"ON_AUDIO_PAUSE\",\n  ON_RATE_CHANGED = \"ON_RATE_CHANGED\",\n  ON_IFRAME_URL_CHANGED = \"ON_IFRAME_URL_CHANGED\",\n  ON_IFRAME_SRC_DOC_CHANGED = \"ON_IFRAME_SRC_DOC_CHANGED\",\n  ON_IFRAME_MESSAGE_RECEIVED = \"ON_IFRAME_MESSAGE_RECEIVED\",\n  ON_SNIPPET_EXECUTE = \"ON_SNIPPET_EXECUTE\",\n  ON_SORT = \"ON_SORT\",\n  ON_CHECKBOX_GROUP_SELECTION_CHANGE = \"ON_CHECKBOX_GROUP_SELECTION_CHANGE\",\n  ON_LIST_PAGE_CHANGE = \"ON_LIST_PAGE_CHANGE\",\n  ON_RECORDING_START = \"ON_RECORDING_START\",\n  ON_RECORDING_COMPLETE = \"ON_RECORDING_COMPLETE\",\n  ON_SWITCH_GROUP_SELECTION_CHANGE = \"ON_SWITCH_GROUP_SELECTION_CHANGE\",\n  ON_JS_FUNCTION_EXECUTE = \"ON_JS_FUNCTION_EXECUTE\",\n  ON_CAMERA_IMAGE_CAPTURE = \"ON_CAMERA_IMAGE_CAPTURE\",\n  ON_CAMERA_IMAGE_SAVE = \"ON_CAMERA_IMAGE_SAVE\",\n  ON_CAMERA_VIDEO_RECORDING_START = \"ON_CAMERA_VIDEO_RECORDING_START\",\n  ON_CAMERA_VIDEO_RECORDING_STOP = \"ON_CAMERA_VIDEO_RECORDING_STOP\",\n  ON_CAMERA_VIDEO_RECORDING_SAVE = \"ON_CAMERA_VIDEO_RECORDING_SAVE\",\n  ON_ENTER_KEY_PRESS = \"ON_ENTER_KEY_PRESS\",\n  ON_BLUR = \"ON_BLUR\",\n  ON_FOCUS = \"ON_FOCUS\",\n  ON_BULK_SAVE = \"ON_BULK_SAVE\",\n  ON_BULK_DISCARD = \"ON_BULK_DISCARD\",\n  ON_ROW_SAVE = \"ON_ROW_SAVE\",\n  ON_ROW_DISCARD = \"ON_ROW_DISCARD\",\n  ON_CODE_DETECTED = \"ON_CODE_DETECTED\",\n  ON_ADD_NEW_ROW_SAVE = \"ON_ADD_NEW_ROW_SAVE\",\n  ON_ADD_NEW_ROW_DISCARD = \"ON_ADD_NEW_ROW_DISCARD\",\n  CUSTOM_WIDGET_EVENT = \"CUSTOM_WIDGET_EVENT\",\n}\n\nexport interface PageAction {\n  id: string;\n  pluginType: PluginType;\n  name: string;\n  jsonPathKeys: string[];\n  timeoutInMillisecond: number;\n  clientSideExecution?: boolean;\n  collectionId?: string;\n}\n\nexport interface ExecuteErrorPayload extends ErrorActionPayload {\n  actionId: string;\n  isPageLoad?: boolean;\n  data: ActionResponse;\n}\n\nexport interface LayoutOnLoadActionErrors {\n  errorType: string;\n  code: number;\n  message: string;\n}\n\n// Group 1 = datasource (https://www.domain.com)\n// Group 2 = path (/nested/path)\n// Group 3 = params (?param=123&param2=12)\nexport const DATASOURCE_URL_EXACT_MATCH_REGEX =\n  /^(https?:\\/{2}\\S+?)(\\/[\\s\\S]*?)?(\\?(?![^{]*})[\\s\\S]*)?$/;\n\nexport const EXECUTION_PARAM_KEY = \"executionParams\";\nexport const EXECUTION_PARAM_REFERENCE_REGEX = /this.params|this\\?.params/g;\nexport const THIS_DOT_PARAMS_KEY = \"$params\";\n\nexport const RESP_HEADER_DATATYPE = \"X-APPSMITH-DATATYPE\";\nexport const API_REQUEST_HEADERS: APIHeaders = {\n  \"Content-Type\": \"application/json\",\n};\nexport const POSTMAN = \"POSTMAN\";\nexport const CURL = \"CURL\";\nexport const Swagger = \"Swagger\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const defaultActionSettings: Record<PluginType, any> = {\n  [PluginType.API]: apiActionSettingsConfig,\n  [PluginType.DB]: queryActionSettingsConfig,\n  [PluginType.SAAS]: saasActionSettingsConfig,\n  [PluginType.REMOTE]: saasActionSettingsConfig,\n  [PluginType.JS]: [],\n  [PluginType.AI]: saasActionSettingsConfig,\n  [PluginType.INTERNAL]: saasActionSettingsConfig,\n  [PluginType.EXTERNAL_SAAS]: saasActionSettingsConfig,\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const defaultActionEditorConfigs: Record<PluginType, any> = {\n  [PluginType.API]: apiActionEditorConfig,\n  [PluginType.DB]: [],\n  [PluginType.SAAS]: [],\n  [PluginType.REMOTE]: [],\n  [PluginType.JS]: [],\n  [PluginType.AI]: [],\n  [PluginType.INTERNAL]: [],\n  [PluginType.EXTERNAL_SAAS]: [],\n};\n\nexport const defaultActionDependenciesConfig: Record<\n  PluginType,\n  Record<string, string[]>\n> = {\n  [PluginType.API]: apiActionDependencyConfig,\n  [PluginType.DB]: {},\n  [PluginType.SAAS]: {},\n  [PluginType.REMOTE]: {},\n  [PluginType.JS]: {},\n  [PluginType.AI]: {},\n  [PluginType.INTERNAL]: {},\n  [PluginType.EXTERNAL_SAAS]: {},\n};\n\nexport const defaultDatasourceFormButtonConfig: Record<PluginType, string[]> = {\n  [PluginType.API]: apiActionDatasourceFormButtonConfig.API,\n  [PluginType.DB]: apiActionDatasourceFormButtonConfig.DB,\n  [PluginType.SAAS]: apiActionDatasourceFormButtonConfig.SAAS,\n  [PluginType.REMOTE]: apiActionDatasourceFormButtonConfig.REMOTE,\n  [PluginType.JS]: [],\n  [PluginType.AI]: apiActionDatasourceFormButtonConfig.AI,\n  [PluginType.INTERNAL]: [],\n  [PluginType.EXTERNAL_SAAS]: apiActionDatasourceFormButtonConfig.EXTERNAL_SAAS,\n};\n","import type { ActionResponse } from \"api/ActionAPI\";\nimport type { PluginType, PluginId } from \"entities/Plugin\";\nimport type { ValidationConfig } from \"constants/PropertyControlConstants\";\nimport type { ActionConfig } from \"entities/Action\";\nimport type { ActionDescription } from \"ee/workers/Evaluation/fns\";\nimport type { Variable } from \"entities/JSCollection\";\nimport type { DependencyMap, DynamicPath } from \"utils/DynamicBindingUtils\";\nimport type { Page } from \"entities/Page\";\nimport type { MetaWidgetsReduxState } from \"reducers/entityReducers/metaWidgetsReducer\";\nimport type { WidgetConfigProps } from \"WidgetProvider/constants\";\nimport type { ActionDataState } from \"ee/reducers/entityReducers/actionsReducer\";\nimport type { WidgetProps } from \"widgets/BaseWidget\";\nimport type { CanvasWidgetsReduxState } from \"ee/reducers/entityReducers/canvasWidgetsReducer\";\nimport type { MetaState } from \"reducers/entityReducers/metaReducer\";\nimport type { AppDataState } from \"reducers/entityReducers/appReducer\";\nimport type { JSCollectionDataState } from \"ee/reducers/entityReducers/jsActionsReducer\";\nimport type { AppTheme } from \"entities/AppTheming\";\nimport type { LoadingEntitiesState } from \"reducers/evaluationReducers/loadingEntitiesReducer\";\nimport type { LayoutSystemTypes } from \"layoutSystems/types\";\nimport type { Module } from \"ee/constants/ModuleConstants\";\nimport type { ModuleInstance } from \"ee/constants/ModuleInstanceConstants\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ActionDispatcher = (...args: any[]) => ActionDescription;\n\nexport const ENTITY_TYPE = {\n  ACTION: \"ACTION\",\n  WIDGET: \"WIDGET\",\n  APPSMITH: \"APPSMITH\",\n  JSACTION: \"JSACTION\",\n} as const;\nexport const JSACTION_TYPE = ENTITY_TYPE.JSACTION;\nexport const ACTION_TYPE = ENTITY_TYPE.ACTION;\n\ntype ValueOf<T> = T[keyof T];\nexport type EntityTypeValue = ValueOf<typeof ENTITY_TYPE>;\n\nexport enum EvaluationSubstitutionType {\n  TEMPLATE = \"TEMPLATE\",\n  PARAMETER = \"PARAMETER\",\n  SMART_SUBSTITUTE = \"SMART_SUBSTITUTE\",\n}\n\n// Action entity types\nexport interface ActionEntity {\n  actionId: string;\n  isLoading: boolean;\n  data: ActionResponse[\"body\"];\n  run: ActionDispatcher | Record<string, unknown>;\n  clear: ActionDispatcher | Record<string, unknown>;\n  responseMeta: {\n    statusCode?: string;\n    isExecutionSuccess: boolean;\n    headers?: unknown;\n  };\n  ENTITY_TYPE: typeof ENTITY_TYPE.ACTION;\n  config: Partial<ActionConfig>;\n  datasourceUrl: string;\n}\n\nexport interface ActionEntityConfig extends EntityConfig {\n  dynamicBindingPathList: DynamicPath[];\n  bindingPaths: Record<string, EvaluationSubstitutionType>;\n  reactivePaths: Record<string, EvaluationSubstitutionType>;\n  ENTITY_TYPE: typeof ENTITY_TYPE.ACTION;\n  dependencyMap: DependencyMap;\n  logBlackList: Record<string, true>;\n  pluginType: PluginType;\n  pluginId: PluginId;\n  actionId: string;\n  name: string;\n  moduleId?: string;\n  moduleInstanceId?: string;\n  isPublic?: boolean;\n}\n\n// JSAction (JSObject) entity Types\n\nexport interface MetaArgs {\n  arguments: Variable[];\n  confirmBeforeExecute: boolean;\n}\n\nexport interface JSActionEntityConfig extends EntityConfig {\n  meta: Record<string, MetaArgs>;\n  dynamicBindingPathList: DynamicPath[];\n  bindingPaths: Record<string, EvaluationSubstitutionType>;\n  reactivePaths: Record<string, EvaluationSubstitutionType>;\n  variables?: Array<string>;\n  dependencyMap: DependencyMap;\n  pluginType: PluginType.JS;\n  name: string;\n  ENTITY_TYPE: typeof ENTITY_TYPE.JSACTION;\n  actionId: string;\n  moduleId?: string;\n  moduleInstanceId?: string;\n  isPublic?: boolean;\n  actionNames: Set<string>;\n}\n\nexport interface JSActionEntity {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [propName: string]: any;\n  body?: string;\n  ENTITY_TYPE: typeof ENTITY_TYPE.JSACTION;\n  actionId: string;\n}\nexport type PagelistEntity = Page[];\n\n// Widget entity Types\n\n// Private widgets do not get evaluated\n// For example, for widget Button1 in a List widget List1, List1.template.Button1.text gets evaluated,\n// so there is no need to evaluate Button1.text\nexport type PrivateWidgets = Record<string, true>;\n\n/**\n *  Map of overriding property as key and overridden property as values\n */\nexport type OverridingPropertyPaths = Record<string, string[]>;\n\nexport enum OverridingPropertyType {\n  META = \"META\",\n  DEFAULT = \"DEFAULT\",\n}\nexport interface overrideDependency {\n  DEFAULT: string;\n  META: string;\n}\n/**\n *  Map of property name as key and value as object with defaultPropertyName and metaPropertyName which it depends on.\n */\nexport type PropertyOverrideDependency = Record<\n  string,\n  Partial<overrideDependency>\n>;\n\nexport interface WidgetConfig extends EntityConfig {\n  bindingPaths: Record<string, EvaluationSubstitutionType>;\n  reactivePaths: Record<string, EvaluationSubstitutionType>;\n  triggerPaths: Record<string, boolean>;\n  validationPaths: Record<string, ValidationConfig>;\n  ENTITY_TYPE: typeof ENTITY_TYPE.WIDGET;\n  logBlackList: Record<string, true>;\n  propertyOverrideDependency: PropertyOverrideDependency;\n  overridingPropertyPaths: OverridingPropertyPaths;\n  privateWidgets: PrivateWidgets;\n}\n\nexport interface EntityConfig {\n  __setters?: Record<string, unknown>;\n  bindingPaths?: Record<string, EvaluationSubstitutionType>;\n  reactivePaths?: Record<string, EvaluationSubstitutionType>;\n  validationPaths?: Record<string, ValidationConfig>;\n  dynamicBindingPathList?: DynamicPath[];\n  dependencyMap?: Record<string, string[]>;\n}\n\n//data factory types\nexport type UnEvalTreeEntityObject =\n  | ActionEntity\n  | JSActionEntity\n  | WidgetEntity;\n\nexport interface WidgetEntity extends WidgetProps {\n  meta: Record<string, unknown>;\n  ENTITY_TYPE: typeof ENTITY_TYPE.WIDGET;\n}\nexport type DataTreeEntityObject =\n  | ActionEntity\n  | JSActionEntity\n  | WidgetEntity\n  | AppsmithEntity;\n\nexport interface WidgetEntityConfig\n  extends Partial<WidgetProps>,\n    Omit<WidgetConfigProps, \"widgetName\" | \"rows\" | \"columns\">,\n    WidgetConfig {\n  widgetId: string;\n  defaultMetaProps: Array<string>;\n  type: string;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  __setters?: Record<string, any>;\n}\n\nexport interface AppsmithEntity extends Omit<AppDataState, \"store\"> {\n  ENTITY_TYPE: typeof ENTITY_TYPE.APPSMITH;\n  store: Record<string, unknown>;\n  theme: AppTheme[\"properties\"];\n  currentPageName: string;\n  workspaceName: string;\n  appName: string;\n  currentEnvironmentName: string;\n}\n\nexport interface DataTreeSeed {\n  actions: ActionDataState;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  editorConfigs: Record<string, any[]>;\n  pluginDependencyConfig: Record<string, DependencyMap>;\n  widgets: CanvasWidgetsReduxState;\n  widgetsMeta: MetaState;\n  appData: AppDataState;\n  jsActions: JSCollectionDataState;\n  theme: AppTheme[\"properties\"];\n  metaWidgets: MetaWidgetsReduxState;\n  isMobile: boolean;\n  moduleInputs: Module[\"inputsForm\"];\n  moduleInstances: Record<string, ModuleInstance> | null;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  moduleInstanceEntities: any;\n  layoutSystemType: LayoutSystemTypes;\n  loadingEntities: LoadingEntitiesState;\n}\n\nexport type DataTreeEntityConfig =\n  | WidgetEntityConfig\n  | ActionEntityConfig\n  | JSActionEntityConfig;\n","export * from \"ce/entities/DataTree/types\";\nimport { ENTITY_TYPE as CE_ENTITY_TYPE } from \"ce/entities/DataTree/types\";\n\nexport const ENTITY_TYPE = {\n  ...CE_ENTITY_TYPE,\n  MODULE_INPUT: \"MODULE_INPUT\",\n  MODULE_INSTANCE: \"MODULE_INSTANCE\",\n} as const;\n\ntype ValueOf<T> = T[keyof T];\nexport type EntityTypeValue = ValueOf<typeof ENTITY_TYPE>;\n","import type {\n  TNavigateToActionType,\n  TNavigateToDescription,\n} from \"./navigateTo\";\nimport navigateTo from \"./navigateTo\";\nimport type { TShowAlertActionType, TShowAlertDescription } from \"./showAlert\";\nimport showAlert from \"./showAlert\";\nimport type {\n  TCloseModalActionType,\n  TCloseModalDescription,\n  TShowModalActionType,\n  TShowModalDescription,\n} from \"./modalFns\";\nimport { closeModal, showModal } from \"./modalFns\";\nimport type { TDownloadActionType, TDownloadDescription } from \"./download\";\nimport download from \"./download\";\nimport type {\n  TPostWindowMessageActionType,\n  TPostWindowMessageDescription,\n} from \"./postWindowMessage\";\nimport postWindowMessage from \"./postWindowMessage\";\nimport type {\n  TCopyToClipboardActionType,\n  TCopyToClipboardDescription,\n} from \"./copyToClipboard\";\nimport copyToClipboard from \"./copyToClipboard\";\nimport type {\n  TResetWidgetActionType,\n  TResetWidgetDescription,\n} from \"./resetWidget\";\nimport resetWidget from \"./resetWidget\";\nimport type {\n  TClearStoreDescription,\n  TRemoveValueDescription,\n  TStoreValueDescription,\n} from \"./storeFns\";\nimport { clearStore, removeValue, storeValue } from \"./storeFns\";\nimport type {\n  TClearActionType,\n  TClearDescription,\n  TRunActionType,\n  TRunDescription,\n} from \"./actionFns\";\nimport run, { clear } from \"./actionFns\";\nimport { isAppsmithEntity } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { ActionEntity } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport type {\n  TGetGeoLocationActionType,\n  TGetGeoLocationDescription,\n  TStopWatchGeoLocationActionType,\n  TStopWatchGeoLocationDescription,\n  TWatchGeoLocationActionType,\n  TWatchGeoLocationDescription,\n} from \"./geolocationFns\";\nimport {\n  getGeoLocation,\n  stopWatchGeoLocation,\n  watchGeoLocation,\n} from \"./geolocationFns\";\nimport { getFnWithGuards, isAsyncGuard } from \"./utils/fnGuard\";\nimport { isRunNClearFnQualifierEntity } from \"ee/workers/Evaluation/fns/utils/isRunNClearFnQualifierEntity\";\n\nexport const getPlatformFunctions = () => {\n  return platformFns;\n};\n\nexport const getEntityFunctions = () => {\n  return entityFns;\n};\n\nconst platformFns = [\n  {\n    name: \"navigateTo\",\n    fn: navigateTo,\n  },\n  {\n    name: \"showAlert\",\n    fn: showAlert,\n  },\n  {\n    name: \"showModal\",\n    fn: showModal,\n  },\n  {\n    name: \"closeModal\",\n    fn: closeModal,\n  },\n  {\n    name: \"download\",\n    fn: download,\n  },\n  {\n    name: \"postWindowMessage\",\n    fn: postWindowMessage,\n  },\n  {\n    name: \"copyToClipboard\",\n    fn: copyToClipboard,\n  },\n  {\n    name: \"resetWidget\",\n    fn: resetWidget,\n  },\n  {\n    name: \"storeValue\",\n    fn: storeValue,\n  },\n  {\n    name: \"removeValue\",\n    fn: removeValue,\n  },\n  {\n    name: \"clearStore\",\n    fn: clearStore,\n  },\n];\n\nconst entityFns = [\n  {\n    name: \"run\",\n    qualifier: (entity: DataTreeEntity) => isRunNClearFnQualifierEntity(entity),\n    fn: (entity: DataTreeEntity, entityName: string) => {\n      const actionEntity = entity as ActionEntity;\n\n      // @ts-expect-error: name is not defined on ActionEntity\n      actionEntity.name = entityName;\n\n      return getFnWithGuards(\n        run.bind(actionEntity as ActionEntity),\n        `${entityName}.run`,\n        [isAsyncGuard],\n      );\n    },\n  },\n  {\n    name: \"clear\",\n    qualifier: (entity: DataTreeEntity) => isRunNClearFnQualifierEntity(entity),\n    fn: (entity: DataTreeEntity, entityName: string) =>\n      getFnWithGuards(\n        clear.bind(entity as ActionEntity),\n        `${entityName}.clear`,\n        [isAsyncGuard],\n      ),\n  },\n  {\n    name: \"getGeoLocation\",\n    path: \"appsmith.geolocation.getCurrentPosition\",\n    qualifier: (entity: DataTreeEntity) => isAppsmithEntity(entity),\n    fn: () =>\n      getFnWithGuards(\n        getGeoLocation,\n        \"appsmith.geolocation.getCurrentPosition\",\n        [isAsyncGuard],\n      ),\n  },\n  {\n    name: \"watchGeoLocation\",\n    path: \"appsmith.geolocation.watchPosition\",\n    qualifier: (entity: DataTreeEntity) => isAppsmithEntity(entity),\n    fn: () =>\n      getFnWithGuards(watchGeoLocation, \"appsmith.geolocation.watchPosition\", [\n        isAsyncGuard,\n      ]),\n  },\n  {\n    name: \"stopWatchGeoLocation\",\n    path: \"appsmith.geolocation.clearWatch\",\n    qualifier: (entity: DataTreeEntity) => isAppsmithEntity(entity),\n    fn: () =>\n      getFnWithGuards(stopWatchGeoLocation, \"appsmith.geolocation.clearWatch\", [\n        isAsyncGuard,\n      ]),\n  },\n];\n\nexport type ActionTriggerKeys =\n  | TClearActionType\n  | TRunActionType\n  | TDownloadActionType\n  | TShowModalActionType\n  | TCloseModalActionType\n  | TShowAlertActionType\n  | TDownloadActionType\n  | TNavigateToActionType\n  | TResetWidgetActionType\n  | TCopyToClipboardActionType\n  | TPostWindowMessageActionType\n  | TGetGeoLocationActionType\n  | TWatchGeoLocationActionType\n  | TStopWatchGeoLocationActionType;\n\nexport const getActionTriggerFunctionNames = (): Record<string, string> => {\n  return ActionTriggerFunctionNames;\n};\n\nconst ActionTriggerFunctionNames: Record<string, string> = {\n  CLEAR_INTERVAL: \"clearInterval\",\n  CLEAR_PLUGIN_ACTION: \"action.clear\",\n  CLOSE_MODAL: \"closeModal\",\n  COPY_TO_CLIPBOARD: \"copyToClipboard\",\n  DOWNLOAD: \"download\",\n  NAVIGATE_TO: \"navigateTo\",\n  RESET_WIDGET_META_RECURSIVE_BY_NAME: \"resetWidget\",\n  RUN_PLUGIN_ACTION: \"action.run\",\n  SET_INTERVAL: \"setInterval\",\n  SHOW_ALERT: \"showAlert\",\n  SHOW_MODAL_BY_NAME: \"showModal\",\n  STORE_VALUE: \"storeValue\",\n  REMOVE_VALUE: \"removeValue\",\n  CLEAR_STORE: \"clearStore\",\n  GET_CURRENT_LOCATION: \"getCurrentLocation\",\n  WATCH_CURRENT_LOCATION: \"watchLocation\",\n  STOP_WATCHING_CURRENT_LOCATION: \"stopWatch\",\n  POST_MESSAGE: \"postWindowMessage\",\n  SET_TIMEOUT: \"setTimeout\",\n  CLEAR_TIMEOUT: \"clearTimeout\",\n};\n\nexport type ActionDescription =\n  | TRunDescription\n  | TClearDescription\n  | TShowModalDescription\n  | TCloseModalDescription\n  | TClearDescription\n  | TStoreValueDescription\n  | TClearStoreDescription\n  | TRemoveValueDescription\n  | TDownloadDescription\n  | TPostWindowMessageDescription\n  | TNavigateToDescription\n  | TShowAlertDescription\n  | TResetWidgetDescription\n  | TCopyToClipboardDescription\n  | TGetGeoLocationDescription\n  | TWatchGeoLocationDescription\n  | TStopWatchGeoLocationDescription;\n","import { getEntityNameAndPropertyPath } from \"ee/workers/Evaluation/evaluationUtils\";\nimport { klona } from \"klona/full\";\nimport { get, set } from \"lodash\";\nimport TriggerEmitter, { BatchKey } from \"../fns/utils/TriggerEmitter\";\nimport ExecutionMetaData from \"../fns/utils/ExecutionMetaData\";\nimport type { JSActionEntity } from \"ee/entities/DataTree/types\";\n\nexport enum PatchType {\n  \"SET\" = \"SET\",\n  \"GET\" = \"GET\",\n}\n\nexport interface Patch {\n  path: string;\n  method: PatchType;\n  value?: unknown;\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type VariableState = Record<string, Record<string, any>>;\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CurrentJSCollectionState = Record<string, any>;\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ResolvedFunctions = Record<string, any>;\n\nexport default class JSObjectCollection {\n  private static resolvedFunctions: ResolvedFunctions = {};\n  private static unEvalState: CurrentJSCollectionState = {};\n  private static variableState: VariableState = {};\n  private static prevUnEvalState: CurrentJSCollectionState = {};\n\n  static setResolvedFunctions(resolvedFunctions: ResolvedFunctions) {\n    this.resolvedFunctions = resolvedFunctions;\n  }\n\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static updateResolvedFunctions(path: string, value: any) {\n    set(this.resolvedFunctions, path, value);\n  }\n\n  static deleteResolvedFunction(entityName: string) {\n    delete this.resolvedFunctions[entityName];\n  }\n\n  static getResolvedFunctions() {\n    return this.resolvedFunctions;\n  }\n\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static updateUnEvalState(path: string, value: any) {\n    set(this.unEvalState, path, value);\n  }\n\n  static deleteUnEvalState(entityName: string) {\n    delete this.unEvalState[entityName];\n  }\n\n  static getUnEvalState() {\n    return this.unEvalState;\n  }\n\n  static setPrevUnEvalState({\n    fullPath,\n    unEvalValue,\n  }: {\n    fullPath: string;\n    unEvalValue: unknown;\n  }) {\n    set(this.prevUnEvalState, fullPath, unEvalValue);\n  }\n\n  static getPrevUnEvalState({ fullPath }: { fullPath: string }) {\n    return get(this.prevUnEvalState, fullPath);\n  }\n\n  static setVariableValue(variableValue: unknown, fullPropertyPath: string) {\n    const { entityName, propertyPath } =\n      getEntityNameAndPropertyPath(fullPropertyPath);\n    const newVarState = { ...this.variableState[entityName] };\n\n    newVarState[propertyPath] = variableValue;\n    this.variableState[entityName] = newVarState;\n    JSObjectCollection.clearCachedVariablesForEvaluationContext(entityName);\n  }\n\n  static getVariableState(\n    JSObjectName?: string,\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): VariableState | Record<string, any> {\n    if (!JSObjectName || !this.variableState) return klona(this.variableState);\n\n    return this.variableState[JSObjectName];\n  }\n\n  static removeVariable(fullPath: string) {\n    const { entityName, propertyPath } = getEntityNameAndPropertyPath(fullPath);\n    const jsObject = this.variableState[entityName];\n\n    if (jsObject && jsObject[propertyPath] !== undefined)\n      delete jsObject[propertyPath];\n  }\n\n  /**Map<JSObjectName, Map<variableName, variableValue> */\n  static cachedJSVariablesByEntityName: Record<string, JSActionEntity> = {};\n\n  /**Computes  Map<JSObjectName, Map<variableName, variableValue> with getters & setters to track JS mutations\n   * We cache and reuse this map. We recreate only when the JSObject's content changes or when any of the variables\n   * gets evaluated\n   */\n  static getVariablesForEvaluationContext(entityName: string) {\n    if (JSObjectCollection.cachedJSVariablesByEntityName[entityName])\n      return JSObjectCollection.cachedJSVariablesByEntityName[entityName];\n\n    const varState = JSObjectCollection.getVariableState(entityName);\n    const variables = Object.entries(varState);\n    const newJSObject = {} as JSActionEntity;\n\n    for (const [varName, varValue] of variables) {\n      let variable = varValue;\n\n      Object.defineProperty(newJSObject, varName, {\n        enumerable: true,\n        configurable: true,\n        get() {\n          TriggerEmitter.emit(BatchKey.process_js_variable_updates, {\n            path: `${entityName}.${varName}`,\n            method: PatchType.GET,\n          });\n\n          return variable;\n        },\n        set(value) {\n          TriggerEmitter.emit(BatchKey.process_js_variable_updates, {\n            path: `${entityName}.${varName}`,\n            method: PatchType.SET,\n            value,\n          });\n          variable = value;\n        },\n      });\n    }\n\n    ExecutionMetaData.setExecutionMetaData({\n      enableJSVarUpdateTracking: true,\n    });\n    JSObjectCollection.cachedJSVariablesByEntityName[entityName] = newJSObject;\n\n    return JSObjectCollection.cachedJSVariablesByEntityName[entityName];\n  }\n\n  static clearCachedVariablesForEvaluationContext(entityName: string) {\n    delete JSObjectCollection.cachedJSVariablesByEntityName[entityName];\n  }\n\n  static clear() {\n    this.variableState = {};\n    this.unEvalState = {};\n    this.prevUnEvalState = {};\n    this.resolvedFunctions = {};\n  }\n}\n","import type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { getAllAsyncFunctions } from \"ee/workers/Evaluation/Actions\";\nimport type { EvaluationError } from \"utils/DynamicBindingUtils\";\nimport { PropertyEvaluationErrorCategory } from \"utils/DynamicBindingUtils\";\nimport type DependencyMap from \"entities/DependencyMap\";\nimport {\n  getAllAsyncJSFunctions,\n  isDataField,\n} from \"workers/common/DataTreeEvaluator/utils\";\nimport { jsPropertiesState } from \"./JSObject/jsPropertiesState\";\nimport { get, isEmpty, toPath } from \"lodash\";\nimport { APP_MODE } from \"entities/App\";\nimport { isAction } from \"ee/workers/Evaluation/evaluationUtils\";\nimport log from \"loglevel\";\nimport * as Sentry from \"@sentry/react\";\nimport { getMemberExpressionObjectFromProperty } from \"@shared/ast\";\n\ninterface ErrorMetaData {\n  userScript: string;\n  source: string;\n}\n\ninterface ExtraData {\n  tree: DataTree;\n  asynFns: Record<string, true>;\n  isViewMode: boolean;\n}\ntype Modifier = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  error: any,\n  metaData: ErrorMetaData & ExtraData,\n) => Partial<{\n  errorMessage: ReturnType<typeof getErrorMessage>;\n  errorCategory: PropertyEvaluationErrorCategory;\n  rootcause: string;\n}>;\n\nconst FOUND_ACTION_IN_DATA_FIELD_EVAL_MESSAGE =\n  \"Found an action invocation during evaluation. Data fields cannot execute actions.\";\nconst UNDEFINED_ACTION_IN_SYNC_EVAL_ERROR =\n  \"Please remove any direct/indirect references to {{actionName}} and try again. Data fields cannot execute framework actions.\";\n\nclass ErrorModifier {\n  private asyncFunctionsNameMap: Record<string, true> = {};\n  private asyncJSFunctionsNames: string[] = [];\n  private isViewMode = true;\n  private dataTree: DataTree = {};\n\n  init(appMode?: APP_MODE) {\n    this.isViewMode = appMode !== APP_MODE.EDIT;\n  }\n\n  updateAsyncFunctions(\n    dataTree: DataTree,\n    configTree: ConfigTree,\n    dependencyMap: DependencyMap,\n  ) {\n    if (this.isViewMode) return;\n\n    const allAsyncEntityFunctions = getAllAsyncFunctions(dataTree, configTree);\n    const allAsyncJSFunctions = getAllAsyncJSFunctions(\n      dataTree,\n      jsPropertiesState.getMap(),\n      dependencyMap,\n      Object.keys(allAsyncEntityFunctions),\n    );\n\n    this.asyncFunctionsNameMap = allAsyncEntityFunctions;\n    this.asyncJSFunctionsNames = allAsyncJSFunctions;\n    this.dataTree = dataTree;\n  }\n  run(\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    error: any,\n    metaData: ErrorMetaData,\n    modifiers: Modifier[],\n  ): {\n    errorMessage: ReturnType<typeof getErrorMessage>;\n    errorCategory?: PropertyEvaluationErrorCategory;\n    rootcause?: string;\n  } {\n    const { source, userScript } = metaData;\n    const result: {\n      errorMessage: ReturnType<typeof getErrorMessage>;\n      errorCategory?: PropertyEvaluationErrorCategory;\n      rootcause?: string;\n    } = {\n      errorMessage: getErrorMessage(error),\n      errorCategory: undefined,\n      rootcause: undefined,\n    };\n\n    for (const errorModifier of modifiers) {\n      const { errorCategory, errorMessage, rootcause } = errorModifier(error, {\n        tree: this.dataTree,\n        asynFns: this.asyncFunctionsNameMap,\n        source,\n        userScript,\n        isViewMode: this.isViewMode,\n      });\n\n      result.errorMessage = errorMessage || result.errorMessage;\n      result.errorCategory = errorCategory || result.errorCategory;\n      result.rootcause = rootcause || result.rootcause;\n    }\n\n    return result;\n  }\n\n  setAsyncInvocationErrorsRootcause(\n    errors: EvaluationError[],\n    asyncFunc: string,\n  ) {\n    return errors.map((error) => {\n      if (isActionInvokedInDataField(error)) {\n        error.errorMessage.message = FOUND_ACTION_IN_DATA_FIELD_EVAL_MESSAGE;\n        error.kind = {\n          category:\n            PropertyEvaluationErrorCategory.ACTION_INVOCATION_IN_DATA_FIELD,\n          rootcause: asyncFunc,\n        };\n      }\n\n      return error;\n    });\n  }\n  addRootcauseToAsyncInvocationErrors(\n    fullPropertyPath: string,\n    configTree: ConfigTree,\n    errors: EvaluationError[],\n    dependencyMap: DependencyMap,\n  ) {\n    if (this.isViewMode) return errors;\n\n    let updatedErrors = errors;\n\n    if (isDataField(fullPropertyPath, configTree)) {\n      const reachableAsyncJSFunctions = dependencyMap.getAllReachableNodes(\n        fullPropertyPath,\n        this.asyncJSFunctionsNames,\n      );\n\n      if (!isEmpty(reachableAsyncJSFunctions))\n        updatedErrors = errorModifier.setAsyncInvocationErrorsRootcause(\n          errors,\n          reachableAsyncJSFunctions[0],\n        );\n    }\n\n    return updatedErrors;\n  }\n}\n\nexport const errorModifier = new ErrorModifier();\n\nconst FOUND_PROMISE_IN_SYNC_EVAL_MESSAGE =\n  \"Found a Promise() during evaluation. Data fields cannot execute asynchronous code.\";\n\nexport class FoundPromiseInSyncEvalError extends Error {\n  constructor() {\n    super();\n    this.name = \"\";\n    this.message = FOUND_PROMISE_IN_SYNC_EVAL_MESSAGE;\n  }\n}\n\nexport class ActionCalledInSyncFieldError extends Error {\n  constructor(actionName: string) {\n    super(actionName);\n\n    if (!actionName) {\n      this.message = \"Async function called in a data field\";\n\n      return;\n    }\n\n    this.name = \"\";\n    this.message = UNDEFINED_ACTION_IN_SYNC_EVAL_ERROR.replaceAll(\n      \"{{actionName}}\",\n      actionName + \"()\",\n    );\n  }\n}\n\nexport const getErrorMessage = (error: Error, name = \"ValidationError\") => {\n  return error.name\n    ? {\n        name: error.name,\n        message: error.message,\n      }\n    : {\n        name,\n        message: error.message,\n      };\n};\n\nexport const getErrorMessageWithType = (error: Error) => {\n  return error.name ? `${error.name}: ${error.message}` : error.message;\n};\n\nfunction isActionInvokedInDataField(error: EvaluationError) {\n  return (\n    error.kind?.category ===\n    PropertyEvaluationErrorCategory.ACTION_INVOCATION_IN_DATA_FIELD\n  );\n}\n\nconst UNDEFINED_TYPE_ERROR_REGEX =\n  /Cannot read properties of undefined \\(reading '([^\\s]+)'/;\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function convertAllDataTypesToString(e: any) {\n  // Functions do not get converted properly with JSON.stringify\n  // So using String fot functions\n  // Types like [], {} get converted to \"\" using String\n  // hence using JSON.stringify for the rest\n  if (typeof e === \"function\") {\n    return String(e);\n  } else {\n    try {\n      return JSON.stringify(e);\n    } catch (error) {\n      log.debug(error);\n      Sentry.captureException(error);\n    }\n  }\n}\n\nexport const ActionInDataFieldErrorModifier: Modifier = (\n  error,\n  { asynFns, isViewMode },\n) => {\n  if (isViewMode) return {};\n\n  const errorMessage = getErrorMessage(error);\n\n  if (\n    error instanceof FoundPromiseInSyncEvalError ||\n    error instanceof ActionCalledInSyncFieldError\n  ) {\n    return {\n      errorMessage,\n      errorCategory:\n        PropertyEvaluationErrorCategory.ACTION_INVOCATION_IN_DATA_FIELD,\n    };\n  }\n\n  if (![\"ReferenceError\", \"TypeError\"].includes(error.name)) return {};\n\n  for (const asyncFunctionFullPath of Object.keys(asynFns)) {\n    const functionNameWithWhiteSpace = \" \" + asyncFunctionFullPath + \" \";\n\n    if (getErrorMessageWithType(error).match(functionNameWithWhiteSpace)) {\n      return {\n        errorMessage: {\n          name: \"ValidationError\",\n          message: UNDEFINED_ACTION_IN_SYNC_EVAL_ERROR.replaceAll(\n            \"{{actionName}}\",\n            asyncFunctionFullPath + \"()\",\n          ),\n        },\n        errorCategory:\n          PropertyEvaluationErrorCategory.ACTION_INVOCATION_IN_DATA_FIELD,\n      };\n    }\n  }\n\n  return {};\n};\n\nexport const TypeErrorModifier: Modifier = (\n  error,\n  { isViewMode, source, tree, userScript },\n) => {\n  if (isViewMode) return {};\n\n  const errorMessage = getErrorMessage(error);\n\n  if (\n    error.name === \"TypeError\" &&\n    errorMessage.message.startsWith(\n      \"Cannot read properties of undefined (reading\",\n    )\n  ) {\n    const matchedString = errorMessage.message.match(\n      UNDEFINED_TYPE_ERROR_REGEX,\n    );\n\n    if (!matchedString) return {};\n\n    const undefinedProperty = matchedString[1];\n    const allMemberExpressionObjects = getMemberExpressionObjectFromProperty(\n      undefinedProperty,\n      userScript,\n    );\n\n    if (isEmpty(allMemberExpressionObjects)) return {};\n\n    const possibleCauses = new Set<string>();\n\n    for (const objectString of allMemberExpressionObjects) {\n      const paths = toPath(objectString);\n      const topLevelEntity = tree[paths[0]];\n\n      if (\n        paths.at(1) === \"data\" &&\n        isAction(topLevelEntity) &&\n        !get(self, `${paths[0]}.data`, undefined)\n      ) {\n        errorMessage.message = `Cannot read data from ${paths[0]}. Please re-run your query.`;\n\n        return {\n          errorMessage,\n          rootcause: `${paths[0]}`,\n        };\n      }\n\n      if (!get(self, objectString, undefined)) {\n        possibleCauses.add(`\"${objectString}\"`);\n      }\n    }\n\n    if (isEmpty(possibleCauses)) return {};\n\n    const possibleCausesArr = Array.from(possibleCauses);\n\n    errorMessage.message = `${\n      possibleCausesArr.length === 1\n        ? `${possibleCausesArr[0]} is undefined`\n        : `${Array.from(possibleCauses).join(\", \")} could be undefined`\n    } . Please fix ${source || \"the binding\"}.`;\n\n    return {\n      errorMessage,\n      rootcause: source,\n    };\n  }\n\n  return {};\n};\n\nexport const PrimitiveErrorModifier: Modifier = (error) => {\n  if (error instanceof Error) {\n    const errorMessage = getErrorMessage(error);\n\n    return { errorMessage };\n  } else {\n    // this covers cases where any primitive value is thrown\n    // for eg., throw \"error\";\n    // These types of errors might have a name/message but are not an instance of Error class\n    const message = convertAllDataTypesToString(error);\n    const errorMessage = {\n      name: error?.name || \"Error\",\n      message: error?.message || message,\n    };\n\n    return { errorMessage };\n  }\n};\n","/**\n * This file contains the utility function to send and receive messages from the worker.\n * TRequestMessage<TBody> is used to send a request to/from the worker.\n * TResponseMessage<TBody> is used to send a response to/from the worker.\n * TDefaultMessage<TBody> is used to send a message to/from worker. Does not expect a response.\n */\n\nexport enum MessageType {\n  REQUEST = \"REQUEST\",\n  RESPONSE = \"RESPONSE\",\n  DEFAULT = \"DEFAULT\",\n}\n\ninterface TRequestMessage<TBody> {\n  body: TBody;\n  messageId: string;\n  messageType: MessageType.REQUEST;\n}\n\ninterface TResponseMessage<TBody> {\n  body: TBody;\n  messageId: string;\n  messageType: MessageType.RESPONSE;\n}\n\nexport interface TDefaultMessage<TBody> {\n  messageId?: string;\n  body: TBody;\n  messageType: MessageType.DEFAULT;\n}\n\nexport type TMessage<TBody> =\n  | TRequestMessage<TBody>\n  | TResponseMessage<TBody>\n  | TDefaultMessage<TBody>;\n\n/** Avoid from using postMessage directly.\n * This function should be used to send messages to the worker and back.\n * Purpose: To have some standardization in the messages that are transferred.\n * TODO: Add support for window postMessage options\n * TODO: Add support for transferable objects.\n */\nexport function sendMessage(\n  this: Worker | typeof globalThis,\n  message: TMessage<unknown>,\n) {\n  this.postMessage(message);\n}\n","import type { DependencyMap, EvaluationError } from \"utils/DynamicBindingUtils\";\nimport {\n  EVAL_ERROR_PATH,\n  isChildPropertyPath,\n  isDynamicValue,\n  PropertyEvaluationErrorType,\n  isPathDynamicTrigger,\n  isPathADynamicBinding,\n} from \"utils/DynamicBindingUtils\";\nimport type { Diff } from \"deep-diff\";\nimport type {\n  DataTreeEntity,\n  DataTree,\n  ConfigTree,\n} from \"entities/DataTree/dataTreeTypes\";\nimport { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport _, { difference, get, has, isEmpty, isNil, set } from \"lodash\";\nimport type { WidgetTypeConfigMap } from \"WidgetProvider/factory\";\nimport { PluginType } from \"entities/Plugin\";\nimport { klona } from \"klona/full\";\nimport { warn as logWarn } from \"loglevel\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport type {\n  JSActionEntityConfig,\n  PrivateWidgets,\n  JSActionEntity,\n  ActionEntity,\n  AppsmithEntity,\n  WidgetEntity,\n  DataTreeEntityConfig,\n  WidgetEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport type { EvalProps } from \"workers/common/DataTreeEvaluator\";\nimport { validateWidgetProperty } from \"workers/common/DataTreeEvaluator/validationUtils\";\nimport { isWidgetActionOrJsObject } from \"ee/entities/DataTree/utils\";\nimport type { Difference } from \"microdiff\";\n\n// Dropdown1.options[1].value -> Dropdown1.options[1]\n// Dropdown1.options[1] -> Dropdown1.options\n// Dropdown1.options -> Dropdown1\nexport const IMMEDIATE_PARENT_REGEX = /^(.*)(\\..*|\\[.*\\])$/;\n\nexport enum DataTreeDiffEvent {\n  NEW = \"NEW\",\n  DELETE = \"DELETE\",\n  EDIT = \"EDIT\",\n  NOOP = \"NOOP\", // No Operation (don’t do anything)\n}\n\nexport interface DataTreeDiff {\n  payload: {\n    propertyPath: string;\n    value?: string;\n  };\n  event: DataTreeDiffEvent;\n}\n\nexport class CrashingError extends Error {}\n\nexport const convertPathToString = (arrPath: Array<string | number>) => {\n  let string = \"\";\n\n  arrPath.forEach((segment) => {\n    if (isInt(segment)) {\n      string = string + \"[\" + segment + \"]\";\n    } else {\n      if (string.length !== 0) {\n        string = string + \".\";\n      }\n\n      string = string + segment;\n    }\n  });\n\n  return string;\n};\n\n// Todo: improve the logic here\n// Right now NaN, Infinity, floats, everything works\nfunction isInt(val: string | number): boolean {\n  return Number.isInteger(val) || (_.isString(val) && /^\\d+$/.test(val));\n}\n\n// Removes the entity name from the property path\nexport function getEntityNameAndPropertyPath(fullPath: string): {\n  entityName: string;\n  propertyPath: string;\n} {\n  const indexOfFirstDot = fullPath.indexOf(\".\");\n\n  if (indexOfFirstDot === -1) {\n    // No dot was found so path is the entity name itself\n    return {\n      entityName: fullPath,\n      propertyPath: \"\",\n    };\n  }\n\n  const entityName = fullPath.substring(0, indexOfFirstDot);\n  const propertyPath = fullPath.substring(indexOfFirstDot + 1);\n\n  return { entityName, propertyPath };\n}\n\nexport function translateCollectionDiffs(\n  propertyPath: string,\n  data: unknown,\n  event: DataTreeDiffEvent,\n) {\n  const dataTreeDiffs: DataTreeDiff[] = [];\n\n  if (Array.isArray(data)) {\n    data.forEach((diff, idx) => {\n      dataTreeDiffs.push({\n        event,\n        payload: {\n          propertyPath: `${propertyPath}[${idx}]`,\n        },\n      });\n    });\n  } else if (isTrueObject(data)) {\n    Object.keys(data).forEach((diffKey) => {\n      const path = `${propertyPath}.${diffKey}`;\n\n      dataTreeDiffs.push({\n        event,\n        payload: {\n          propertyPath: path,\n        },\n      });\n    });\n  }\n\n  return dataTreeDiffs;\n}\n\n//these paths are not required to go through evaluate tree as these are internal properties\nconst ignorePathsForEvalRegex =\n  \".(reactivePaths|bindingPaths|triggerPaths|validationPaths|dynamicBindingPathList)\";\n\n//match if paths are part of ignorePathsForEvalRegex\nconst isUninterestingChangeForDependencyUpdate = (path: string) => {\n  return path.match(ignorePathsForEvalRegex);\n};\n\nexport const translateDiffEventToDataTreeDiffEvent = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  difference: Diff<any, any>,\n  unEvalDataTree: DataTree,\n): DataTreeDiff | DataTreeDiff[] => {\n  let result: DataTreeDiff | DataTreeDiff[] = {\n    payload: {\n      propertyPath: \"\",\n      value: \"\",\n    },\n    event: DataTreeDiffEvent.NOOP,\n  };\n\n  if (!difference.path) {\n    return result;\n  }\n\n  const propertyPath = convertPathToString(difference.path);\n\n  // add propertyPath to NOOP event\n  result.payload = {\n    propertyPath,\n    value: \"\",\n  };\n\n  //we do not need evaluate these paths because these are internal paths\n  const isUninterestingPathForUpdateTree =\n    isUninterestingChangeForDependencyUpdate(propertyPath);\n\n  if (!!isUninterestingPathForUpdateTree) {\n    return result;\n  }\n\n  const { entityName } = getEntityNameAndPropertyPath(propertyPath);\n  const entity = unEvalDataTree[entityName];\n  const isJsAction = isJSAction(entity);\n\n  switch (difference.kind) {\n    case \"N\": {\n      result.event = DataTreeDiffEvent.NEW;\n      result.payload = {\n        propertyPath,\n      };\n      break;\n    }\n    case \"D\": {\n      result.event = DataTreeDiffEvent.DELETE;\n      result.payload = { propertyPath };\n      break;\n    }\n    case \"E\": {\n      const rhsChange =\n        typeof difference.rhs === \"string\" &&\n        (isDynamicValue(difference.rhs) || isJsAction);\n\n      const lhsChange =\n        typeof difference.lhs === \"string\" &&\n        (isDynamicValue(difference.lhs) || isJsAction);\n\n      if (rhsChange || lhsChange) {\n        result = [\n          {\n            event:\n              difference.lhs === undefined\n                ? DataTreeDiffEvent.NEW\n                : DataTreeDiffEvent.EDIT,\n            payload: {\n              propertyPath,\n              value: difference.rhs,\n            },\n          },\n        ];\n        /**\n         * If lhs is an array/object\n         * Add delete events for all memberExpressions\n         */\n\n        const dataTreeDeleteDiffs = translateCollectionDiffs(\n          propertyPath,\n          difference.lhs,\n          DataTreeDiffEvent.DELETE,\n        );\n\n        result = result.concat(dataTreeDeleteDiffs);\n      } else if (difference.lhs === undefined || difference.rhs === undefined) {\n        // Handle static value changes that change structure that can lead to\n        // old bindings being eligible\n        if (difference.lhs === undefined && !isNil(difference.rhs)) {\n          result.event = DataTreeDiffEvent.NEW;\n          result.payload = { propertyPath };\n        }\n\n        if (difference.rhs === undefined && !isNil(difference.lhs)) {\n          result = [\n            {\n              event: DataTreeDiffEvent.EDIT,\n              payload: {\n                propertyPath,\n                value: difference.rhs,\n              },\n            },\n          ];\n\n          const dataTreeDeleteDiffs = translateCollectionDiffs(\n            propertyPath,\n            difference.lhs,\n            DataTreeDiffEvent.DELETE,\n          );\n\n          result = dataTreeDeleteDiffs.concat(result);\n        }\n      } else if (\n        isTrueObject(difference.lhs) &&\n        !isTrueObject(difference.rhs)\n      ) {\n        // This will happen for static value changes where a property went\n        // from being an object to any other type like string or number\n        // in such a case we want to delete all nested paths of the\n        // original lhs object\n\n        result = translateCollectionDiffs(\n          propertyPath,\n          difference.lhs,\n          DataTreeDiffEvent.DELETE,\n        );\n\n        // when an object is being replaced by an array\n        // list all new array accessors that are being added\n        // so dependencies will be created based on existing bindings\n        if (Array.isArray(difference.rhs)) {\n          result = result.concat(\n            translateCollectionDiffs(\n              propertyPath,\n              difference.rhs,\n              DataTreeDiffEvent.NEW,\n            ),\n          );\n        }\n      } else if (\n        !isTrueObject(difference.lhs) &&\n        isTrueObject(difference.rhs)\n      ) {\n        // This will happen for static value changes where a property went\n        // from being any other type like string or number to an object\n        // in such a case we want to add all nested paths of the\n        // new rhs object\n        result = translateCollectionDiffs(\n          propertyPath,\n          difference.rhs,\n          DataTreeDiffEvent.NEW,\n        );\n\n        // when an array is being replaced by an object\n        // remove all array accessors that are deleted\n        // so dependencies by existing bindings are removed\n        if (Array.isArray(difference.lhs)) {\n          result = result.concat(\n            translateCollectionDiffs(\n              propertyPath,\n              difference.lhs,\n              DataTreeDiffEvent.DELETE,\n            ),\n          );\n        }\n      }\n\n      break;\n    }\n    case \"A\": {\n      return translateDiffEventToDataTreeDiffEvent(\n        {\n          ...difference.item,\n          path: [...difference.path, difference.index],\n        },\n        unEvalDataTree,\n      );\n    }\n    default: {\n      break;\n    }\n  }\n\n  return result;\n};\n\nexport const translateDiffArrayIndexAccessors = (\n  propertyPath: string,\n  array: unknown[],\n  event: DataTreeDiffEvent,\n) => {\n  const result: DataTreeDiff[] = [];\n\n  array.forEach((data, index) => {\n    const path = `${propertyPath}[${index}]`;\n\n    result.push({\n      event,\n      payload: {\n        propertyPath: path,\n      },\n    });\n  });\n\n  return result;\n};\n/*\n  Table1.selectedRow\n  Table1.selectedRow.email: [\"Input1.defaultText\"]\n */\n\nexport const addDependantsOfNestedPropertyPaths = (\n  parentPaths: Array<string>,\n  inverseMap: DependencyMap,\n): Set<string> => {\n  const withNestedPaths: Set<string> = new Set();\n  const dependantNodes = Object.keys(inverseMap);\n\n  parentPaths.forEach((propertyPath) => {\n    withNestedPaths.add(propertyPath);\n    dependantNodes\n      .filter((dependantNodePath) =>\n        isChildPropertyPath(propertyPath, dependantNodePath),\n      )\n      .forEach((dependantNodePath) => {\n        inverseMap[dependantNodePath].forEach((path) => {\n          withNestedPaths.add(path);\n        });\n      });\n  });\n\n  return withNestedPaths;\n};\n\nexport function isWidget(\n  entity: Partial<DataTreeEntity> | DataTreeEntityConfig,\n): entity is WidgetEntity | WidgetEntityConfig {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.WIDGET\n  );\n}\n\nexport const shouldSuppressAutoComplete = (widget: WidgetEntity) =>\n  Boolean(widget.suppressAutoComplete);\n\nexport const shouldSuppressDebuggerError = (widget: WidgetEntity) =>\n  Boolean(widget.suppressDebuggerError);\n\nexport function isAction(\n  entity: Partial<DataTreeEntity>,\n): entity is ActionEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.ACTION\n  );\n}\n\nexport function isAppsmithEntity(\n  entity: DataTreeEntity,\n): entity is AppsmithEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.APPSMITH\n  );\n}\n\nexport function isJSAction(entity: DataTreeEntity): entity is JSActionEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.JSACTION\n  );\n}\n/**\n *\n * isAnyJSAction checks if the entity is a JSAction ( or a JSModuleInstance on EE )\n */\nexport function isAnyJSAction(entity: DataTreeEntity) {\n  return isJSAction(entity);\n}\n\nexport function isJSActionConfig(\n  entity: DataTreeEntityConfig,\n): entity is JSActionEntityConfig {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.JSACTION\n  );\n}\n\nexport function isJSObject(entity: DataTreeEntity): entity is JSActionEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.JSACTION &&\n    \"pluginType\" in entity &&\n    entity.pluginType === PluginType.JS\n  );\n}\n\nexport function isDataTreeEntity(entity: unknown) {\n  return !!entity && typeof entity === \"object\" && \"ENTITY_TYPE\" in entity;\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const serialiseToBigInt = (value: any) =>\n  JSON.stringify(value, (_, v) => (typeof v === \"bigint\" ? v.toString() : v));\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const removeFunctionsAndSerialzeBigInt = (value: any) =>\n  JSON.parse(serialiseToBigInt(value));\n// We need to remove functions from data tree to avoid any unexpected identifier while JSON parsing\n// Check issue https://github.com/appsmithorg/appsmith/issues/719\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const removeFunctions = (value: any) => {\n  if (_.isFunction(value)) {\n    return \"Function call\";\n  } else if (_.isObject(value)) {\n    return removeFunctionsAndSerialzeBigInt(value);\n  } else {\n    return value;\n  }\n};\n\nexport const makeParentsDependOnChildren = (\n  depMap: DependencyMap,\n  allkeys: Record<string, true>,\n): DependencyMap => {\n  //return depMap;\n  // Make all parents depend on child\n  Object.keys(depMap).forEach((key) => {\n    depMap = makeParentsDependOnChild(depMap, key, allkeys);\n    depMap[key].forEach((path) => {\n      depMap = makeParentsDependOnChild(depMap, path, allkeys);\n    });\n  });\n\n  return depMap;\n};\n\nexport const makeParentsDependOnChild = (\n  depMap: DependencyMap,\n  child: string,\n  allkeys: Record<string, true>,\n): DependencyMap => {\n  const result: DependencyMap = depMap;\n  let curKey = child;\n\n  if (!allkeys[curKey]) {\n    logWarn(\n      `makeParentsDependOnChild - ${curKey} is not present in dataTree.`,\n      \"This might result in a cyclic dependency.\",\n    );\n  }\n\n  let matches: Array<string> | null;\n\n  // Note: The `=` is intentional\n  // Stops looping when match is null\n  while ((matches = curKey.match(IMMEDIATE_PARENT_REGEX)) !== null) {\n    const parentKey = matches[1];\n    // Todo: switch everything to set.\n    const existing = new Set(result[parentKey] || []);\n\n    existing.add(curKey);\n    result[parentKey] = Array.from(existing);\n    curKey = parentKey;\n  }\n\n  return result;\n};\n\n// The idea is to find the immediate parents of the property paths\n// e.g. For Table1.selectedRow.email, the parent is Table1.selectedRow\nexport const getImmediateParentsOfPropertyPaths = (\n  propertyPaths: Array<string>,\n): Array<string> => {\n  // Use a set to ensure that we dont have duplicates\n  const parents: Set<string> = new Set();\n\n  propertyPaths.forEach((path) => {\n    const matches = path.match(IMMEDIATE_PARENT_REGEX);\n\n    if (matches !== null) {\n      parents.add(matches[1]);\n    }\n  });\n\n  return Array.from(parents);\n};\n\nexport const getAllPaths = (\n  records: Record<string, unknown> | unknown,\n  curKey = \"\",\n  result: Record<string, true> = {},\n): Record<string, true> => {\n  // Add the key if it exists\n  if (curKey) result[curKey] = true;\n\n  if (Array.isArray(records)) {\n    for (let i = 0; i < records.length; i++) {\n      const tempKey = curKey ? `${curKey}[${i}]` : `${i}`;\n\n      getAllPaths(records[i], tempKey, result);\n    }\n  } else if (isTrueObject(records)) {\n    for (const key of Object.keys(records)) {\n      const tempKey = curKey ? `${curKey}.${key}` : `${key}`;\n\n      getAllPaths(records[key], tempKey, result);\n    }\n  }\n\n  return result;\n};\nexport const getAllPathsBasedOnDiffPaths = (\n  records: Record<string, unknown> | unknown,\n  diff: DataTreeDiff[],\n  // this argument would be mutable\n  previousResult: Record<string, true> = {},\n): Record<string, true> => {\n  const newResult = previousResult;\n\n  diff.forEach((curr) => {\n    const { event, payload } = curr;\n\n    if (event === DataTreeDiffEvent.DELETE) {\n      delete newResult[payload.propertyPath];\n    }\n\n    if (event === DataTreeDiffEvent.NEW || event === DataTreeDiffEvent.EDIT) {\n      const newDataSegments = get(records, payload.propertyPath);\n\n      // directly mutates on the result so we don't have to merge it back to the result\n      getAllPaths(newDataSegments, payload.propertyPath, newResult);\n    }\n  });\n\n  return newResult;\n};\nexport const trimDependantChangePaths = (\n  changePaths: Set<string>,\n  dependencyMap: DependencyMap,\n): Array<string> => {\n  const trimmedPaths = [];\n\n  for (const path of changePaths) {\n    let foundADependant = false;\n\n    if (path in dependencyMap) {\n      const dependants = dependencyMap[path];\n\n      for (const dependantPath of dependants) {\n        if (changePaths.has(dependantPath)) {\n          foundADependant = true;\n          break;\n        }\n      }\n    }\n\n    if (!foundADependant) {\n      trimmedPaths.push(path);\n    }\n  }\n\n  return trimmedPaths;\n};\n\nexport function getSafeToRenderDataTree(\n  tree: DataTree,\n  widgetTypeConfigMap: WidgetTypeConfigMap,\n  configTree: ConfigTree,\n) {\n  return Object.keys(tree).reduce((tree, entityKey: string) => {\n    const entity = tree[entityKey];\n\n    if (!isWidget(entity)) {\n      return tree;\n    }\n\n    const entityConfig = configTree[entityKey] as WidgetEntityConfig;\n\n    const safeToRenderEntity = { ...entity };\n\n    // Set user input values to their parsed values\n    Object.entries(entityConfig.validationPaths).forEach(\n      ([property, validation]) => {\n        const value = _.get(entity, property);\n        // Pass it through parse\n        const { parsed } = validateWidgetProperty(\n          validation,\n          value,\n          entityConfig,\n          property,\n        );\n\n        _.set(safeToRenderEntity, property, parsed);\n      },\n    );\n    // Set derived values to undefined or else they would go as bindings\n    Object.keys(\n      widgetTypeConfigMap[entityConfig.type].derivedProperties,\n    ).forEach((property) => {\n      _.set(safeToRenderEntity, property, undefined);\n    });\n\n    return { ...tree, [entityKey]: safeToRenderEntity };\n  }, tree);\n}\n\nexport const addErrorToEntityProperty = ({\n  configTree,\n  errors,\n  evalProps,\n  fullPropertyPath,\n}: {\n  errors: EvaluationError[];\n  fullPropertyPath: string;\n  evalProps: EvalProps;\n  configTree: ConfigTree;\n}) => {\n  const { entityName, propertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const isPrivateEntityPath =\n    getAllPrivateWidgetsInDataTree(configTree)[entityName];\n  const logBlackList = get(configTree, `${entityName}.logBlackList`, {});\n\n  if (propertyPath && !(propertyPath in logBlackList) && !isPrivateEntityPath) {\n    const errorPath = `${entityName}.${EVAL_ERROR_PATH}['${propertyPath}']`;\n    const existingErrors = get(evalProps, errorPath, []) as EvaluationError[];\n\n    set(evalProps, errorPath, existingErrors.concat(errors));\n  }\n};\n\nexport const resetValidationErrorsForEntityProperty = ({\n  evalProps,\n  fullPropertyPath,\n}: {\n  fullPropertyPath: string;\n  evalProps: EvalProps;\n}) => {\n  const { entityName, propertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n\n  if (propertyPath) {\n    const errorPath = `${entityName}.${EVAL_ERROR_PATH}['${propertyPath}']`;\n    const existingErrorsExceptValidation = (\n      _.get(evalProps, errorPath, []) as EvaluationError[]\n    ).filter(\n      (error) => error.errorType !== PropertyEvaluationErrorType.VALIDATION,\n    );\n\n    _.set(evalProps, errorPath, existingErrorsExceptValidation);\n  }\n};\n\n// For the times when you need to know if something truly an object like { a: 1, b: 2}\n// typeof, lodash.isObject and others will return false positives for things like array, null, etc\nexport const isTrueObject = (\n  item: unknown,\n): item is Record<string, unknown> => {\n  return Object.prototype.toString.call(item) === \"[object Object]\";\n};\n\n/**\n * This function finds the datatype of the given value.\n * typeof, lodash and others will return false positives for things like array, wrapper objects, etc\n * @param value\n * @returns datatype of the received value as string\n */\nexport const findDatatype = (value: unknown) => {\n  return Object.prototype.toString.call(value).slice(8, -1).toLowerCase();\n};\n\nexport const isDynamicLeaf = (\n  unEvalTree: DataTree,\n  propertyPath: string,\n  configTree: ConfigTree,\n) => {\n  const [entityName, ...propPathEls] = _.toPath(propertyPath);\n\n  // Framework feature: Top level items are never leaves\n  if (entityName === propertyPath) return false;\n\n  // Ignore if this was a delete op\n  if (!unEvalTree.hasOwnProperty(entityName)) return false;\n\n  const entityConfig = configTree[entityName];\n  const entity = unEvalTree[entityName];\n\n  if (!isWidgetActionOrJsObject(entity)) return false;\n\n  const relativePropertyPath = convertPathToString(propPathEls);\n\n  return (\n    (!isEmpty(entityConfig.reactivePaths) &&\n      relativePropertyPath in entityConfig.reactivePaths) ||\n    (isWidget(entityConfig) &&\n      relativePropertyPath in entityConfig?.triggerPaths)\n  );\n};\n\nexport const addWidgetPropertyDependencies = ({\n  widgetConfig,\n  widgetName,\n}: {\n  widgetConfig: WidgetEntityConfig;\n  widgetName: string;\n}) => {\n  const dependencies: DependencyMap = {};\n\n  Object.entries(widgetConfig.propertyOverrideDependency).forEach(\n    ([overriddenPropertyKey, overridingPropertyKeyMap]) => {\n      const existingDependenciesSet = new Set(\n        dependencies[`${widgetName}.${overriddenPropertyKey}`] || [],\n      );\n\n      // add meta dependency\n      overridingPropertyKeyMap.META &&\n        existingDependenciesSet.add(\n          `${widgetName}.${overridingPropertyKeyMap.META}`,\n        );\n      // add default dependency\n      overridingPropertyKeyMap.DEFAULT &&\n        existingDependenciesSet.add(\n          `${widgetName}.${overridingPropertyKeyMap.DEFAULT}`,\n        );\n\n      dependencies[`${widgetName}.${overriddenPropertyKey}`] = [\n        ...existingDependenciesSet,\n      ];\n    },\n  );\n\n  return dependencies;\n};\n\nexport const isPrivateEntityPath = (\n  privateWidgets: PrivateWidgets,\n  fullPropertyPath: string,\n) => {\n  const entityName = fullPropertyPath.split(\".\")[0];\n\n  if (Object.keys(privateWidgets).indexOf(entityName) !== -1) {\n    return true;\n  }\n\n  return false;\n};\n\nexport const getAllPrivateWidgetsInDataTree = (\n  configTree: ConfigTree,\n): PrivateWidgets => {\n  let privateWidgets: PrivateWidgets = {};\n\n  Object.keys(configTree).forEach((entityName) => {\n    const entityConfig = configTree[entityName] as WidgetEntityConfig;\n\n    if (isWidget(entityConfig) && !_.isEmpty(entityConfig.privateWidgets)) {\n      privateWidgets = { ...privateWidgets, ...entityConfig.privateWidgets };\n    }\n  });\n\n  return privateWidgets;\n};\n\nexport const getDataTreeWithoutPrivateWidgets = (\n  dataTree: DataTree,\n  configTree: ConfigTree,\n): DataTree => {\n  const privateWidgets = getAllPrivateWidgetsInDataTree(configTree);\n  const privateWidgetNames = Object.keys(privateWidgets);\n  const treeWithoutPrivateWidgets = _.omit(dataTree, privateWidgetNames);\n\n  return treeWithoutPrivateWidgets;\n};\n\nconst getDataTreeWithoutSuppressedAutoComplete = (\n  dataTree: DataTree,\n): DataTree => {\n  const entityIds = Object.keys(dataTree).filter((entityName) => {\n    const entity = dataTree[entityName];\n\n    return (\n      isWidget(entity) && shouldSuppressAutoComplete(entity as WidgetEntity)\n    );\n  });\n\n  return _.omit(dataTree, entityIds);\n};\n\nexport const getDataTreeForAutocomplete = (\n  dataTree: DataTree,\n  configTree: ConfigTree,\n): DataTree => {\n  const treeWithoutPrivateWidgets = getDataTreeWithoutPrivateWidgets(\n    dataTree,\n    configTree,\n  );\n  const treeWithoutSuppressedAutoComplete =\n    getDataTreeWithoutSuppressedAutoComplete(treeWithoutPrivateWidgets);\n\n  return treeWithoutSuppressedAutoComplete;\n};\n\n/**\n *  overrideWidgetProperties method has logic to update overriddenPropertyPaths when overridingPropertyPaths are evaluated.\n *\n *  when we evaluate widget's overridingPropertyPaths for example defaultText of input widget,\n *  we override the values like text and meta.text in dataTree, these values are called as overriddenPropertyPaths\n *\n * @param {{\n *   entity: WidgetEntity;\n *   propertyPath: string;\n *   value: unknown;\n *   currentTree: DataTree;\n *   evalMetaUpdates: EvalMetaUpdates;\n * }} params\n * @return {*}\n */\nexport const overrideWidgetProperties = (params: {\n  entity: WidgetEntity;\n  propertyPath: string;\n  value: unknown;\n  currentTree: DataTree;\n  configTree: ConfigTree;\n  evalMetaUpdates: EvalMetaUpdates;\n  fullPropertyPath: string;\n  isNewWidget: boolean;\n  shouldUpdateGlobalContext?: boolean;\n  overriddenProperties?: string[];\n  safeTree?: DataTree;\n}) => {\n  const {\n    configTree,\n    currentTree,\n    entity,\n    evalMetaUpdates,\n    fullPropertyPath,\n    isNewWidget,\n    overriddenProperties,\n    propertyPath,\n    safeTree,\n    shouldUpdateGlobalContext,\n    value,\n  } = params;\n  const { entityName } = getEntityNameAndPropertyPath(fullPropertyPath);\n\n  const configEntity = configTree[entityName] as WidgetEntityConfig;\n\n  if (propertyPath in configEntity.overridingPropertyPaths) {\n    const clonedValue = klona(value);\n    const overridingPropertyPaths =\n      configEntity.overridingPropertyPaths[propertyPath];\n\n    const pathsNotToOverride = widgetPathsNotToOverride(\n      isNewWidget,\n      propertyPath,\n      configEntity,\n    );\n\n    overridingPropertyPaths.forEach((overriddenPropertyPath) => {\n      const overriddenPropertyPathArray = overriddenPropertyPath.split(\".\");\n\n      if (pathsNotToOverride.includes(overriddenPropertyPath)) return;\n\n      const fullPath = [entityName, ...overriddenPropertyPathArray];\n\n      _.set(currentTree, fullPath, clonedValue);\n\n      if (safeTree) _.set(safeTree, fullPath, klona(value));\n\n      if (shouldUpdateGlobalContext) {\n        _.set(self, fullPath, clonedValue);\n      }\n\n      overriddenProperties?.push(overriddenPropertyPath);\n\n      // evalMetaUpdates has all updates from property which overrides meta values.\n      if (\n        propertyPath.split(\".\")[0] !== \"meta\" &&\n        overriddenPropertyPathArray[0] === \"meta\"\n      ) {\n        const metaPropertyPath = overriddenPropertyPathArray.slice(1);\n\n        evalMetaUpdates.push({\n          widgetId: entity.widgetId,\n          metaPropertyPath,\n          value: clonedValue,\n        });\n      }\n    });\n  } else if (\n    propertyPath in configEntity.propertyOverrideDependency &&\n    value === undefined\n  ) {\n    // When a reset a widget its meta value becomes undefined, ideally they should reset to default value.\n    // below we handle logic to reset meta values to default values.\n    const propertyOverridingKeyMap =\n      configEntity.propertyOverrideDependency[propertyPath];\n\n    if (propertyOverridingKeyMap.DEFAULT) {\n      const defaultValue = entity[propertyOverridingKeyMap.DEFAULT];\n\n      if (defaultValue !== undefined) {\n        const clonedDefaultValue = klona(defaultValue);\n        const fullPath = [entityName, ...propertyPath.split(\".\")];\n\n        _.set(currentTree, fullPath, clonedDefaultValue);\n\n        if (safeTree) _.set(safeTree, fullPath, klona(defaultValue));\n\n        if (shouldUpdateGlobalContext) {\n          _.set(self, fullPath, clonedDefaultValue);\n        }\n\n        return {\n          overwriteParsedValue: true,\n          newValue: clonedDefaultValue,\n        };\n      }\n    }\n  }\n};\n\nexport const isATriggerPath = (\n  entityConfig: DataTreeEntityConfig,\n  propertyPath: string,\n) => {\n  return (\n    isWidget(entityConfig) && isPathDynamicTrigger(entityConfig, propertyPath)\n  );\n};\n\n// Checks if entity newly got added to the unevalTree\nexport const isNewEntity = (updates: Set<string>, entityName: string) => {\n  return updates.has(entityName);\n};\n\nconst widgetPathsNotToOverride = (\n  isNewWidget: boolean,\n  propertyPath: string,\n  entityConfig: WidgetEntityConfig,\n) => {\n  let pathsNotToOverride: string[] = [];\n  const overriddenPropertyPaths =\n    entityConfig.overridingPropertyPaths[propertyPath];\n\n  // Check if widget has pre-existing meta values (although newly added to the unevalTree)\n  if (isNewWidget && entityConfig.isMetaPropDirty) {\n    const overriddenMetaPaths = overriddenPropertyPaths.filter(\n      (path) => path.split(\".\")[0] === \"meta\",\n    );\n\n    // If widget is newly added but has pre-existing meta values, this meta values take precedence and should not be overridden\n    pathsNotToOverride = [...overriddenMetaPaths];\n    // paths which these meta values override should also not get overridden\n    overriddenMetaPaths.forEach((path) => {\n      if (entityConfig.overridingPropertyPaths.hasOwnProperty(path)) {\n        pathsNotToOverride = [\n          ...pathsNotToOverride,\n          ...entityConfig.overridingPropertyPaths[path],\n        ];\n      }\n    });\n  }\n\n  return pathsNotToOverride;\n};\n\nconst isWidgetDefaultPropertyPath = (\n  widget: WidgetEntityConfig,\n  propertyPath: string,\n) => {\n  for (const property of Object.keys(widget.propertyOverrideDependency)) {\n    const overrideDependency = widget.propertyOverrideDependency[property];\n\n    if (overrideDependency.DEFAULT === propertyPath) return true;\n  }\n\n  return false;\n};\n\nconst isMetaWidgetTemplate = (widget: WidgetEntity) => {\n  return !!widget.siblingMetaWidgets;\n};\n\n// When a default value changes in a template(widgets used to generate other widgets), meta values of metaWidgets not present in the unevalTree become stale\nexport function getStaleMetaStateIds(args: {\n  entity: WidgetEntity;\n  entityConfig: WidgetEntityConfig;\n  propertyPath: string;\n  isNewWidget: boolean;\n  metaWidgets: string[];\n}) {\n  const { entity, entityConfig, isNewWidget, metaWidgets, propertyPath } = args;\n\n  return !isNewWidget &&\n    isWidgetDefaultPropertyPath(entityConfig, propertyPath) &&\n    isMetaWidgetTemplate(entity)\n    ? difference(entity.siblingMetaWidgets, metaWidgets)\n    : [];\n}\n\nexport function convertJSFunctionsToString(\n  jscollections: Record<string, JSActionEntity>,\n  configTree: ConfigTree,\n) {\n  const collections = klona(jscollections);\n\n  Object.keys(collections).forEach((collectionName) => {\n    const jsCollection = collections[collectionName];\n    const jsCollectionConfig = configTree[\n      collectionName\n    ] as JSActionEntityConfig;\n    const jsFunctions = jsCollectionConfig.meta;\n\n    for (const funcName in jsFunctions) {\n      if (jsCollection[funcName] instanceof String) {\n        if (has(jsCollection, [funcName, \"data\"])) {\n          set(jsCollection, [`${funcName}.data`], {});\n        }\n\n        set(jsCollection, funcName, jsCollection[funcName].toString());\n      }\n    }\n  });\n\n  return collections;\n}\n\nexport const isAPathDynamicBindingPath = (\n  entity: DataTreeEntity,\n  entityConfig: DataTreeEntityConfig,\n  propertyPath: string,\n) => {\n  return (\n    isWidgetActionOrJsObject(entity) &&\n    isPathADynamicBinding(entityConfig, propertyPath)\n  );\n};\n\nexport const isNotEntity = (entity: DataTreeEntity) => {\n  return !isAction(entity) && !isWidget(entity) && !isJSAction(entity);\n};\n\nexport const isEntityAction = (entity: DataTreeEntity) => {\n  return isAction(entity);\n};\n\nexport const isPropertyAnEntityAction = (\n  entity: DataTreeEntity,\n  propertyPath: string,\n  entityConfig: DataTreeEntityConfig,\n) => {\n  if (!isJSAction(entity)) return false;\n\n  const { actionNames } = entityConfig as JSActionEntityConfig;\n\n  return actionNames.has(propertyPath);\n};\n\nexport const convertMicroDiffToDeepDiff = (\n  microDiffDifferences: Difference[],\n): Diff<unknown, unknown>[] =>\n  microDiffDifferences.map((microDifference) => {\n    const { path, type } = microDifference;\n\n    //convert microDiff format to deepDiff format\n    if (type === \"CREATE\") {\n      return {\n        kind: \"N\",\n        path,\n        rhs: microDifference.value,\n      };\n    }\n\n    if (type === \"REMOVE\") {\n      return {\n        kind: \"D\",\n        path,\n        lhs: microDifference.oldValue,\n      };\n    }\n\n    return {\n      kind: \"E\",\n      path,\n      lhs: microDifference.oldValue,\n      rhs: microDifference.value,\n    };\n  });\n","import { convertPathToString } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { Diff } from \"deep-diff\";\nimport type { DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { get, set, unset } from \"lodash\";\n\nexport type TDataStore = Record<string, Record<string, unknown>>;\nexport default class DataStore {\n  private static store: TDataStore = {};\n\n  static setActionData(fullPath: string, value: unknown) {\n    set(DataStore.store, fullPath, value);\n  }\n\n  static getActionData(fullPath: string): unknown | undefined {\n    return get(DataStore.store, fullPath, undefined);\n  }\n  static getDataStore() {\n    return DataStore.store;\n  }\n  static deleteActionData(fullPath: string) {\n    unset(DataStore.store, fullPath);\n  }\n  static clear() {\n    DataStore.store = {};\n  }\n\n  static replaceDataStore(store: TDataStore) {\n    DataStore.store = store;\n  }\n\n  static update(dataTreeDiff: Diff<DataTree, DataTree>[]) {\n    const deleteDiffs = dataTreeDiff.filter((diff) => diff.kind === \"D\");\n\n    deleteDiffs.forEach((diff) => {\n      const deletedPath = diff.path || [];\n      const deletedPathString = convertPathToString(deletedPath);\n\n      DataStore.deleteActionData(deletedPathString);\n    });\n  }\n}\n","import { DATA_BIND_REGEX_GLOBAL } from \"constants/BindingsConstants\";\nimport { isBoolean, get, set, isString } from \"lodash\";\nimport type {\n  ConditionalOutput,\n  FormConfigEvalObject,\n  FormEvalOutput,\n} from \"reducers/evaluationReducers/formEvaluationReducer\";\nimport type { FormConfigType, HiddenType } from \"./BaseControl\";\nimport type { Diff } from \"deep-diff\";\nimport { diff } from \"deep-diff\";\nimport { MongoDefaultActionConfig } from \"constants/DatasourceEditorConstants\";\nimport { klona } from \"klona/full\";\nimport type { FeatureFlags } from \"ee/entities/FeatureFlag\";\nimport _ from \"lodash\";\nimport { getType, Types } from \"utils/TypeHelpers\";\nimport { FIELD_REQUIRED_ERROR, createMessage } from \"ee/constants/messages\";\nimport { FEATURE_FLAG } from \"ee/entities/FeatureFlag\";\nimport { InputTypes } from \"components/constants\";\n\n// This function checks if the form is dirty\n// We needed this in the cases where datasources are created from APIs and the initial value\n// already has url set. If user presses back button, we need to show the confirmation dialog\nexport const getIsFormDirty = (\n  isFormDirty: boolean,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  formData: any,\n  isNewDatasource: boolean,\n  isRestPlugin: boolean,\n  currentEditingEnvId: string,\n) => {\n  const url = isRestPlugin\n    ? get(\n        formData,\n        `datastoreStorages.${currentEditingEnvId}.datasourceConfiguration.url`,\n        \"\",\n      )\n    : \"\";\n\n  if (!isFormDirty && isNewDatasource && isRestPlugin && url.length === 0) {\n    return true;\n  }\n\n  return isFormDirty;\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const getTrimmedData = (formData: any) => {\n  const dataType = getType(formData);\n  const isArrayorObject = (type: ReturnType<typeof getType>) =>\n    type === Types.ARRAY || type === Types.OBJECT;\n\n  if (isArrayorObject(dataType)) {\n    Object.keys(formData).map((key) => {\n      const valueType = getType(formData[key]);\n\n      if (isArrayorObject(valueType)) {\n        getTrimmedData(formData[key]);\n      } else if (valueType === Types.STRING) {\n        _.set(formData, key, formData[key].trim());\n      }\n    });\n  }\n\n  return formData;\n};\n\nexport const normalizeValues = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  formData: any,\n  configDetails: Record<string, string>,\n) => {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const checked: Record<string, any> = {};\n  const configProperties = Object.keys(configDetails);\n\n  for (const configProperty of configProperties) {\n    const controlType = configDetails[configProperty];\n\n    if (controlType === \"KEYVALUE_ARRAY\") {\n      const properties = configProperty.split(\"[*].\");\n\n      if (checked[properties[0]]) continue;\n\n      checked[properties[0]] = 1;\n      const values = _.get(formData, properties[0], []);\n      const newValues: ({ [s: string]: unknown } | ArrayLike<unknown>)[] = [];\n\n      values.forEach(\n        (object: { [s: string]: unknown } | ArrayLike<unknown>) => {\n          const isEmpty = Object.values(object).every((x) => x === \"\");\n\n          if (!isEmpty) {\n            newValues.push(object);\n          }\n        },\n      );\n\n      if (newValues.length) {\n        formData = _.set(formData, properties[0], newValues);\n      } else {\n        formData = _.set(formData, properties[0], []);\n      }\n    }\n  }\n\n  return formData;\n};\n\nexport const validate = (\n  requiredFields: Record<string, FormConfigType>,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  values: any,\n  currentEnvId?: string,\n) => {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const errors = {} as any;\n\n  Object.keys(requiredFields).forEach((fieldConfigProperty) => {\n    // Do not check for required fields if the field is not part of the current environment\n    if (\n      !!currentEnvId &&\n      currentEnvId.length > 0 &&\n      !fieldConfigProperty.includes(currentEnvId)\n    ) {\n      return;\n    }\n\n    const fieldConfig = requiredFields[fieldConfigProperty];\n\n    if (fieldConfig.controlType === \"KEYVALUE_ARRAY\") {\n      const configProperty = (fieldConfig.configProperty as string).split(\n        \"[*].\",\n      );\n      const arrayValues = _.get(values, configProperty[0], []);\n      const keyValueArrayErrors: Record<string, string>[] = [];\n\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      arrayValues.forEach((value: any, index: number) => {\n        const objectKeys = Object.keys(value);\n        const keyValueErrors: Record<string, string> = {};\n\n        if (\n          !value[objectKeys[0]] ||\n          (isString(value[objectKeys[0]]) && !value[objectKeys[0]].trim())\n        ) {\n          keyValueErrors[objectKeys[0]] = createMessage(FIELD_REQUIRED_ERROR);\n          keyValueArrayErrors[index] = keyValueErrors;\n        }\n\n        if (\n          !value[objectKeys[1]] ||\n          (isString(value[objectKeys[1]]) && !value[objectKeys[1]].trim())\n        ) {\n          keyValueErrors[objectKeys[1]] = createMessage(FIELD_REQUIRED_ERROR);\n          keyValueArrayErrors[index] = keyValueErrors;\n        }\n      });\n\n      if (keyValueArrayErrors.length) {\n        _.set(errors, configProperty[0], keyValueArrayErrors);\n      }\n    } else {\n      const value = _.get(values, fieldConfigProperty);\n\n      if (_.isNil(value) || (isString(value) && _.isEmpty(value.trim()))) {\n        _.set(errors, fieldConfigProperty, \"This field is required\");\n      }\n    }\n  });\n\n  return !_.isEmpty(errors);\n};\n\nexport const evaluateCondtionWithType = (\n  conditions: Array<boolean> | undefined,\n  type: string | undefined,\n) => {\n  if (conditions) {\n    let flag;\n\n    //this is where each conditions gets evaluated\n    if (conditions.length > 1) {\n      if (type === \"AND\") {\n        // TODO: Fix this the next time the file is edited\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        flag = conditions.reduce((acc: any, item: boolean) => {\n          return acc && item;\n        }, conditions[0]);\n      } else if (type === \"OR\") {\n        // TODO: Fix this the next time the file is edited\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        flag = conditions.reduce((acc: any, item: boolean) => {\n          return acc || item;\n        }, undefined);\n      }\n    } else {\n      flag = conditions[0];\n    }\n\n    return flag;\n  }\n};\n\nexport const isHiddenConditionsEvaluation = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  values: any,\n  hidden?: HiddenType,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any => {\n  if (!!hidden && !isBoolean(hidden)) {\n    //if nested condtions are there recursively from bottom to top call this function on each condtion\n    let conditionType, conditions;\n\n    if (\"conditionType\" in hidden) {\n      conditionType = hidden.conditionType;\n    }\n\n    if (\"conditions\" in hidden) {\n      conditions = hidden.conditions;\n    }\n\n    if (Array.isArray(conditions)) {\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      conditions = conditions.map((rule: any) => {\n        return isHiddenConditionsEvaluation(values, rule);\n      });\n    } else {\n      return caculateIsHidden(values, hidden);\n    }\n\n    return evaluateCondtionWithType(conditions, conditionType);\n  }\n};\n\nexport const caculateIsHidden = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  values: any,\n  hiddenConfig?: HiddenType,\n  featureFlags?: FeatureFlags,\n  viewMode?: boolean,\n) => {\n  if (!!hiddenConfig && !isBoolean(hiddenConfig)) {\n    let valueAtPath;\n    let value, comparison;\n\n    if (\"path\" in hiddenConfig) {\n      valueAtPath = get(values, hiddenConfig.path);\n    }\n\n    if (\"value\" in hiddenConfig) {\n      value = hiddenConfig.value;\n    }\n\n    if (\"comparison\" in hiddenConfig) {\n      comparison = hiddenConfig.comparison;\n    }\n\n    let flagValue: keyof FeatureFlags = FEATURE_FLAG.TEST_FLAG;\n\n    if (\"flagValue\" in hiddenConfig) {\n      flagValue = hiddenConfig.flagValue;\n    }\n\n    switch (comparison) {\n      case \"EQUALS\":\n        return valueAtPath === value;\n      case \"NOT_EQUALS\":\n        return valueAtPath !== value;\n      case \"GREATER\":\n        return valueAtPath > value;\n      case \"LESSER\":\n        return valueAtPath < value;\n      case \"IN\":\n        return Array.isArray(value) && value.includes(valueAtPath);\n      case \"NOT_IN\":\n        return Array.isArray(value) && !value.includes(valueAtPath);\n      case \"FEATURE_FLAG\":\n        // FEATURE_FLAG comparision is used to hide previous configs,\n        // and show new configs if feature flag is enabled, if disabled/ not present,\n        // previous config would be shown as is\n        return !!featureFlags && featureFlags[flagValue] === value;\n      case \"VIEW_MODE\":\n        // This can be used to decide which form controls to show in view mode or edit mode depending on the value.\n        return viewMode === value;\n      case \"DEFINED_AND_NOT_EQUALS\":\n        return !!valueAtPath && valueAtPath !== value;\n      default:\n        return true;\n    }\n  }\n};\n\nexport const isHidden = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  values: any,\n  hiddenConfig?: HiddenType,\n  featureFlags?: FeatureFlags,\n  viewMode?: boolean,\n) => {\n  if (!!hiddenConfig && !isBoolean(hiddenConfig)) {\n    if (\"conditionType\" in hiddenConfig) {\n      //check if nested conditions exist\n      return isHiddenConditionsEvaluation(values, hiddenConfig);\n    } else {\n      return caculateIsHidden(values, hiddenConfig, featureFlags, viewMode);\n    }\n  }\n\n  return !!hiddenConfig;\n};\n\nexport enum ViewTypes {\n  JSON = \"json\",\n  COMPONENT = \"component\",\n}\n\nexport const alternateViewTypeInputConfig = () => {\n  return {\n    label: \"\",\n    isValid: true,\n    controlType: \"QUERY_DYNAMIC_INPUT_TEXT\",\n    evaluationSubstitutionType: \"TEMPLATE\",\n    inputType: \"TEXT_WITH_BINDING\",\n    // showLineNumbers: true,\n  };\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const getViewType = (values: any, configProperty: string) => {\n  if (\n    configProperty.startsWith(\"actionConfiguration.formData\") &&\n    configProperty.endsWith(\".data\")\n  ) {\n    const pathForViewType = configProperty.replace(\".data\", \".viewType\");\n\n    return get(values, pathForViewType, ViewTypes.COMPONENT);\n  } else {\n    return ViewTypes.COMPONENT;\n  }\n};\n\nexport const switchViewType = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  values: any,\n  configProperty: string,\n  viewType: string,\n  formName: string,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  changeFormValue: (formName: string, path: string, value: any) => void,\n) => {\n  const newViewType =\n    viewType === ViewTypes.JSON ? ViewTypes.COMPONENT : ViewTypes.JSON;\n  const pathForJsonData = configProperty.replace(\".data\", \".jsonData\");\n  const pathForComponentData = configProperty.replace(\n    \".data\",\n    \".componentData\",\n  );\n  const componentData = get(values, pathForComponentData);\n  const currentData = get(values, configProperty, \"\");\n  const stringifiedCurrentData = JSON.stringify(currentData, null, \"\\t\");\n\n  if (newViewType === ViewTypes.JSON) {\n    changeFormValue(formName, pathForComponentData, currentData);\n\n    // when switching to JSON, we always want a form to json conversion of the data.\n    changeFormValue(\n      formName,\n      configProperty,\n      isString(currentData)\n        ? currentData\n        : stringifiedCurrentData.replace(/\\\\/g, \"\"),\n    );\n  } else {\n    changeFormValue(formName, pathForJsonData, currentData);\n\n    if (!!componentData) {\n      changeFormValue(formName, configProperty, componentData);\n    }\n  }\n\n  changeFormValue(\n    formName,\n    configProperty.replace(\".data\", \".viewType\"),\n    newViewType,\n  );\n};\n\n// Function that extracts the initial value from the JSON configs\nexport const getConfigInitialValues = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  config: Record<string, any>[],\n  multipleViewTypesSupported = false,\n  // Used in case when we want to not have encrypted fields in the response since we need to compare\n  // the initial values with the server response and server response does not send encrypted fields.\n  // With this param we can remove false negatives during comparison.\n  includeEncryptedFields = true,\n) => {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const configInitialValues: Record<string, any> = {};\n\n  // We expect the JSON configs to be an array of objects\n  if (!Array.isArray(config)) return configInitialValues;\n\n  // Function to loop through the configs and extract the initial values\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const parseConfig = (section: any): any => {\n    if (\"initialValue\" in section) {\n      if (section.controlType === \"KEYVALUE_ARRAY\") {\n        section.initialValue.forEach(\n          (initialValue: string | number, index: number) => {\n            const configProperty = section.configProperty.replace(\"*\", index);\n\n            set(configInitialValues, configProperty, initialValue);\n          },\n        );\n      } else {\n        if (\n          !includeEncryptedFields &&\n          (section.encrypted || section.dataType === InputTypes.PASSWORD)\n        ) {\n          return;\n        }\n\n        set(configInitialValues, section.configProperty, section.initialValue);\n      }\n    } else if (section.controlType === \"WHERE_CLAUSE\") {\n      let logicalTypes = [];\n\n      if (\"logicalTypes\" in section && section.logicalTypes.length > 0) {\n        logicalTypes = section.logicalTypes;\n      } else {\n        logicalTypes = [\n          {\n            label: \"OR\",\n            value: \"OR\",\n          },\n          {\n            label: \"AND\",\n            value: \"AND\",\n          },\n        ];\n      }\n\n      set(\n        configInitialValues,\n        `${section.configProperty}.condition`,\n        logicalTypes[0].value,\n      );\n\n      if (\n        multipleViewTypesSupported &&\n        section.configProperty.includes(\".data\")\n      ) {\n        set(\n          configInitialValues,\n          section.configProperty.replace(\".data\", \".viewType\"),\n          \"component\",\n        );\n        set(\n          configInitialValues,\n          section.configProperty.replace(\".data\", \".componentData.condition\"),\n          logicalTypes[0].value,\n        );\n      }\n    }\n\n    if (\"children\" in section) {\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      section.children.forEach((childSection: any) => {\n        parseConfig(childSection);\n      });\n    } else if (\"schema\" in section) {\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      section.schema.forEach((childSection: any) => {\n        parseConfig(childSection);\n      });\n    } else if (\n      \"configProperty\" in section &&\n      multipleViewTypesSupported &&\n      section.configProperty.includes(\".data\")\n    ) {\n      set(\n        configInitialValues,\n        section.configProperty.replace(\".data\", \".viewType\"),\n        \"component\",\n      );\n\n      if (section.configProperty in configInitialValues) {\n        set(\n          configInitialValues,\n          section.configProperty.replace(\".data\", \".componentData\"),\n          configInitialValues[section.configProperty],\n        );\n      }\n    }\n  };\n\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  config.forEach((section: any) => {\n    parseConfig(section);\n  });\n\n  return configInitialValues;\n};\n\nexport const actionPathFromName = (\n  actionName: string,\n  name: string,\n): string => {\n  const ActionConfigStarts = \"actionConfiguration.\";\n  let path = name;\n\n  if (path.startsWith(ActionConfigStarts)) {\n    path = \"config.\" + path.slice(ActionConfigStarts.length);\n  }\n\n  return `${actionName}.${path}`;\n};\n\nexport enum PaginationSubComponent {\n  Limit = \"limit\",\n  Offset = \"offset\",\n  Cursor = \"cursor\",\n}\n\nexport enum SortingSubComponent {\n  Column = \"column\",\n  Order = \"order\",\n}\n\nexport enum WhereClauseSubComponent {\n  Condition = \"condition\",\n  Children = \"children\",\n  Key = \"key\",\n  Value = \"value\",\n}\n\nexport const allowedControlTypes = [\"DROP_DOWN\", \"QUERY_DYNAMIC_INPUT_TEXT\"];\n\nconst extractExpressionObject = (\n  config: string,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  path: any,\n  parentPath: string,\n): FormConfigEvalObject => {\n  const bindingPaths: FormConfigEvalObject = {};\n  const expressions = config.match(DATA_BIND_REGEX_GLOBAL);\n\n  if (Array.isArray(expressions) && expressions.length > 0) {\n    const completePath = parentPath.length > 0 ? `${parentPath}.${path}` : path;\n\n    expressions.forEach((exp) => {\n      bindingPaths[completePath] = {\n        expression: exp,\n        output: \"\",\n      };\n    });\n  }\n\n  return bindingPaths;\n};\n\nexport const extractEvalConfigFromFormConfig = (\n  formConfig: FormConfigType,\n  paths: string[],\n  parentPath = \"\",\n  bindingsFound: FormConfigEvalObject = {},\n) => {\n  paths.forEach((path: string) => {\n    if (!(path in formConfig)) return;\n\n    const config = get(formConfig, path, \"\");\n\n    if (typeof config === \"string\") {\n      bindingsFound = {\n        ...bindingsFound,\n        ...extractExpressionObject(config, path, parentPath),\n      };\n    } else if (typeof config === \"object\") {\n      bindingsFound = {\n        ...bindingsFound,\n        ...extractEvalConfigFromFormConfig(\n          config,\n          Object.keys(config),\n          parentPath.length > 0 ? `${parentPath}.${path}` : path,\n          bindingsFound,\n        ),\n      };\n    }\n  });\n\n  return bindingsFound;\n};\n\n// Extract the output of conditionals attached to the form from the state\nexport const extractConditionalOutput = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  section: any,\n  formEvaluationState: FormEvalOutput,\n): ConditionalOutput => {\n  let conditionalOutput: ConditionalOutput = {};\n\n  if (\n    section.hasOwnProperty(\"propertyName\") &&\n    formEvaluationState.hasOwnProperty(section.propertyName)\n  ) {\n    conditionalOutput = formEvaluationState[section.propertyName];\n  } else if (\n    section.hasOwnProperty(\"configProperty\") &&\n    formEvaluationState.hasOwnProperty(section.configProperty)\n  ) {\n    conditionalOutput = formEvaluationState[section.configProperty];\n  } else if (\n    section.hasOwnProperty(\"identifier\") &&\n    !!section.identifier &&\n    formEvaluationState.hasOwnProperty(section.identifier)\n  ) {\n    conditionalOutput = formEvaluationState[section.identifier];\n  }\n\n  return conditionalOutput;\n};\n\n// Function to check if the section config is allowed to render (Only for UQI forms)\nexport const checkIfSectionCanRender = (\n  conditionalOutput: ConditionalOutput,\n) => {\n  // By default, allow the section to render. This is to allow for the case where no conditional is provided.\n  // The evaluation state disallows the section to render if the condition is not met. (Checkout formEval.ts)\n  let allowToRender = true;\n\n  if (\n    conditionalOutput.hasOwnProperty(\"visible\") &&\n    typeof conditionalOutput.visible === \"boolean\"\n  ) {\n    allowToRender = conditionalOutput.visible;\n  }\n\n  if (\n    conditionalOutput.hasOwnProperty(\"evaluateFormConfig\") &&\n    !!conditionalOutput.evaluateFormConfig &&\n    conditionalOutput.evaluateFormConfig.hasOwnProperty(\n      \"updateEvaluatedConfig\",\n    ) &&\n    typeof conditionalOutput.evaluateFormConfig.updateEvaluatedConfig ===\n      \"boolean\"\n  ) {\n    allowToRender = conditionalOutput.evaluateFormConfig.updateEvaluatedConfig;\n  }\n\n  return allowToRender;\n};\n\n// Function to check if the section config is enabled (Only for UQI forms)\nexport const checkIfSectionIsEnabled = (\n  conditionalOutput: ConditionalOutput,\n) => {\n  // By default, the section is enabled. This is to allow for the case where no conditional is provided.\n  // The evaluation state disables the section if the condition is not met. (Checkout formEval.ts)\n  let enabled = true;\n\n  if (\n    conditionalOutput.hasOwnProperty(\"enabled\") &&\n    typeof conditionalOutput.enabled === \"boolean\"\n  ) {\n    enabled = conditionalOutput.enabled;\n  }\n\n  return enabled;\n};\n\n// Function to modify the section config based on the output of evaluations\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const modifySectionConfig = (section: any, enabled: boolean): any => {\n  if (!enabled) {\n    section.disabled = true;\n  } else {\n    section.disabled = false;\n  }\n\n  return section;\n};\n\nexport const updateEvaluatedSectionConfig = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  section: any,\n  conditionalOutput: ConditionalOutput,\n  enabled = true,\n) => {\n  // we deep clone the section coming from the editorConfig to prevent any mutations of\n  // the editorConfig in the redux state.\n  // just spreading the object does a shallow clone(top level cloning), so we use the klona package to deep clone\n  // klona is faster than deepClone from lodash.\n\n  // leaving the commented code as a reminder of the above observation.\n  // const updatedSection = { ...section };\n\n  const updatedSection = klona(section);\n\n  let evaluatedConfig: FormConfigEvalObject = {};\n\n  if (\n    conditionalOutput.hasOwnProperty(\"evaluateFormConfig\") &&\n    !!conditionalOutput.evaluateFormConfig &&\n    conditionalOutput.evaluateFormConfig.hasOwnProperty(\n      \"updateEvaluatedConfig\",\n    ) &&\n    typeof conditionalOutput.evaluateFormConfig.updateEvaluatedConfig ===\n      \"boolean\" &&\n    conditionalOutput.evaluateFormConfig.updateEvaluatedConfig\n  ) {\n    evaluatedConfig =\n      conditionalOutput.evaluateFormConfig.evaluateFormConfigObject;\n\n    const paths = Object.keys(evaluatedConfig);\n\n    paths.forEach((path: string) => {\n      set(updatedSection, path, evaluatedConfig[path].output);\n    });\n  }\n\n  return modifySectionConfig(updatedSection, enabled);\n};\n\nexport function fixActionPayloadForMongoQuery(\n  action?: unknown,\n): unknown | undefined {\n  if (!action) return action;\n\n  /* eslint-disable */\n  //@ts-nocheck\n  try {\n    let actionObjectDiff: undefined | Diff<any, any>[] = diff(\n      action,\n      MongoDefaultActionConfig,\n    );\n    if (actionObjectDiff) {\n      actionObjectDiff = actionObjectDiff.filter((diff) => diff.kind === \"N\");\n      for (let i = 0; i < actionObjectDiff.length; i++) {\n        let path = \"\";\n        let value = \"\";\n        //kind = N indicates a newly added property/element\n        //This property is present in initialValues but not in action object\n        if (\n          actionObjectDiff &&\n          actionObjectDiff[i].hasOwnProperty(\"kind\") &&\n          actionObjectDiff[i].path &&\n          Array.isArray(actionObjectDiff[i].path) &&\n          actionObjectDiff[i]?.path?.length &&\n          actionObjectDiff[i]?.kind === \"N\"\n        ) {\n          // @ts-expect-error: Types are not available\n          if (typeof actionObjectDiff[i]?.path[0] === \"string\") {\n            // @ts-expect-error: Types are not available\n            path = actionObjectDiff[i]?.path?.join(\".\");\n          }\n          // @ts-expect-error: Types are not available\n          value = actionObjectDiff[i]?.rhs;\n          set(action, path, value);\n        }\n      }\n    }\n    return action;\n    //@ts-check\n  } catch (error) {\n    console.error(\"Error adding default paths in Mongo query\");\n    return action;\n  }\n}\n\n// Function to check if the config has KEYVALUE_ARRAY controlType with more than 1 dependent children\nexport function isKVArray(children: Array<any>) {\n  if (!Array.isArray(children) || children.length < 2) return false;\n  return (\n    children[0].controlType && children[0].controlType === \"KEYVALUE_ARRAY\"\n  );\n}\n\nexport const formatFileSize = (sizeInBytes: number) => {\n  const FILE_SIZE = {\n    KB: 1024,\n    MB: 1024 * 1024,\n    GB: 1024 * 1024 * 1024,\n  };\n\n  if (sizeInBytes < FILE_SIZE.KB) {\n    return `${sizeInBytes} B`;\n  } else if (sizeInBytes < FILE_SIZE.MB) {\n    return `${Math.round(sizeInBytes / FILE_SIZE.KB)} KB`;\n  } else if (sizeInBytes < FILE_SIZE.GB) {\n    return `${Math.round(sizeInBytes / FILE_SIZE.MB)} MB`;\n  }\n\n  return `${Math.round(sizeInBytes / FILE_SIZE.GB)} GB`;\n};\n","import { APPSMITH_NAMESPACED_FUNCTIONS as EE_APPSMITH_NAMESPACED_FUNCTIONS } from \"ee/entities/Engine/actionHelpers\";\n\nexport enum APPSMITH_GLOBAL_FUNCTIONS {\n  navigateTo = \"navigateTo\",\n  showAlert = \"showAlert\",\n  showModal = \"showModal\",\n  closeModal = \"closeModal\",\n  storeValue = \"storeValue\",\n  removeValue = \"removeValue\",\n  clearStore = \"clearStore\",\n  download = \"download\",\n  copyToClipboard = \"copyToClipboard\",\n  resetWidget = \"resetWidget\",\n  setInterval = \"setInterval\",\n  clearInterval = \"clearInterval\",\n  postWindowMessage = \"postWindowMessage\",\n}\n\nexport enum APPSMITH_NAMESPACED_FUNCTIONS {\n  getGeolocation = \"appsmith.geolocation.getCurrentPosition\",\n  watchGeolocation = \"appsmith.geolocation.watchPosition\",\n  stopWatchGeolocation = \"appsmith.geolocation.clearWatch\",\n}\n\nexport enum APPSMITH_INTEGRATIONS {\n  none = \"none\",\n  integration = \"integration\",\n  jsFunction = \"jsFunction\",\n}\n\nexport const AppsmithFunction = {\n  ...APPSMITH_INTEGRATIONS,\n  ...APPSMITH_GLOBAL_FUNCTIONS,\n  ...APPSMITH_NAMESPACED_FUNCTIONS,\n  ...EE_APPSMITH_NAMESPACED_FUNCTIONS,\n};\n\nexport const AppsmithFunctionsWithFields = [\n  ...Object.values(APPSMITH_NAMESPACED_FUNCTIONS),\n  ...Object.keys(APPSMITH_GLOBAL_FUNCTIONS),\n];\n\nexport const RESET_CHILDREN_OPTIONS = [\n  { label: \"true\", value: \"true\", id: \"true\" },\n  { label: \"false\", value: \"false\", id: \"false\" },\n];\n\nexport const FILE_TYPE_OPTIONS = [\n  { label: \"Select file type (optional)\", value: \"\", id: \"\" },\n  { label: \"Plain text\", value: \"'text/plain'\", id: \"text/plain\" },\n  { label: \"HTML\", value: \"'text/html'\", id: \"text/html\" },\n  { label: \"CSV\", value: \"'text/csv'\", id: \"text/csv\" },\n  { label: \"JSON\", value: \"'application/json'\", id: \"application/json\" },\n  { label: \"JPEG\", value: \"'image/jpeg'\", id: \"image/jpeg\" },\n  { label: \"PNG\", value: \"'image/png'\", id: \"image/png\" },\n  { label: \"SVG\", value: \"'image/svg+xml'\", id: \"image/svg+xml\" },\n];\n\nexport const NAVIGATION_TARGET_FIELD_OPTIONS = [\n  {\n    label: \"Same window\",\n    value: \"'SAME_WINDOW'\",\n    id: \"SAME_WINDOW\",\n  },\n  {\n    label: \"New window\",\n    value: \"'NEW_WINDOW'\",\n    id: \"NEW_WINDOW\",\n  },\n];\n\nexport const ViewTypes = {\n  SELECTOR_VIEW: \"SELECTOR_VIEW\",\n  KEY_VALUE_VIEW: \"KEY_VALUE_VIEW\",\n  TEXT_VIEW: \"TEXT_VIEW\",\n  BOOL_VIEW: \"BOOL_VIEW\",\n  TAB_VIEW: \"TAB_VIEW\",\n  NO_VIEW: \"NO_VIEW\",\n  ACTION_SELECTOR_VIEW: \"ACTION_SELECTOR_VIEW\",\n};\n\nexport const NAVIGATE_TO_TAB_OPTIONS = {\n  PAGE_NAME: \"page-name\",\n  URL: \"url\",\n};\n\nexport const NEW_MODAL_LABEL = \"New Modal\";\nconst SELECT_OPTIONS_LABEL = \"Select file type (optional)\";\n\nexport const DEFAULT_LABELS = [NEW_MODAL_LABEL, SELECT_OPTIONS_LABEL];\n\nexport const DEFAULT_SELECTOR_VIEW_TEXT = \"Select Action\";\n\nexport const EMPTY_BINDING = \"{{}}\";\nexport const EMPTY_BINDING_WITH_EMPTY_OBJECT = \"{{{}}}\";\n\nexport enum FieldType {\n  PARAMS_FIELD = \"PARAMS_FIELD\",\n  ACTION_SELECTOR_FIELD = \"ACTION_SELECTOR_FIELD\",\n  ON_SUCCESS_FIELD = \"ON_SUCCESS_FIELD\",\n  ON_ERROR_FIELD = \"ON_ERROR_FIELD\",\n  SHOW_MODAL_FIELD = \"SHOW_MODAL_FIELD\",\n  CLOSE_MODAL_FIELD = \"CLOSE_MODAL_FIELD\",\n  PAGE_SELECTOR_FIELD = \"PAGE_SELECTOR_FIELD\",\n  KEY_VALUE_FIELD = \"KEY_VALUE_FIELD\",\n  URL_FIELD = \"URL_FIELD\",\n  ALERT_TEXT_FIELD = \"ALERT_TEXT_FIELD\",\n  ALERT_TYPE_SELECTOR_FIELD = \"ALERT_TYPE_SELECTOR_FIELD\",\n  KEY_TEXT_FIELD_REMOVE_VALUE = \"KEY_TEXT_FIELD_REMOVE_VALUE\",\n  KEY_TEXT_FIELD_STORE_VALUE = \"KEY_TEXT_FIELD_STORE_VALUE\",\n  VALUE_TEXT_FIELD = \"VALUE_TEXT_FIELD\",\n  QUERY_PARAMS_FIELD = \"QUERY_PARAMS_FIELD\",\n  DOWNLOAD_DATA_FIELD = \"DOWNLOAD_DATA_FIELD\",\n  DOWNLOAD_FILE_NAME_FIELD = \"DOWNLOAD_FILE_NAME_FIELD\",\n  DOWNLOAD_FILE_TYPE_FIELD = \"DOWNLOAD_FILE_TYPE_FIELD\",\n  COPY_TEXT_FIELD = \"COPY_TEXT_FIELD\",\n  NAVIGATION_TARGET_FIELD = \"NAVIGATION_TARGET_FIELD\",\n  WIDGET_NAME_FIELD = \"WIDGET_NAME_FIELD\",\n  RESET_CHILDREN_FIELD = \"RESET_CHILDREN_FIELD\",\n  ARGUMENT_KEY_VALUE_FIELD = \"ARGUMENT_KEY_VALUE_FIELD\",\n  CALLBACK_FUNCTION_FIELD_SET_INTERVAL = \"CALLBACK_FUNCTION_FIELD_SET_INTERVAL\",\n  CALLBACK_FUNCTION_FIELD_GEOLOCATION = \"CALLBACK_FUNCTION_FIELD_GEOLOCATION\",\n  DELAY_FIELD = \"DELAY_FIELD\",\n  ID_FIELD = \"ID_FIELD\",\n  CLEAR_INTERVAL_ID_FIELD = \"CLEAR_INTERVAL_ID_FIELD\",\n  MESSAGE_FIELD = \"MESSAGE_FIELD\",\n  TARGET_ORIGIN_FIELD = \"TARGET_ORIGIN_FIELD\",\n  SOURCE_FIELD = \"SOURCE_FIELD\",\n  PAGE_NAME_AND_URL_TAB_SELECTOR_FIELD = \"PAGE_NAME_AND_URL_TAB_SELECTOR_FIELD\",\n  API_AND_QUERY_SUCCESS_FAILURE_TAB_FIELD = \"API_AND_QUERY_SUCCESS_FAILURE_TAB_FIELD\",\n  CALLBACK_FUNCTION_API_AND_QUERY = \"CALLBACK_FUNCTION_API_AND_QUERY\",\n  ADD_ACTION = \"ADD_ACTION\",\n}\n\nexport const Variants = {\n  mainBlock: \"mainBlock\",\n  callbackBlock: \"callbackBlock\",\n  hoverBorder: \"hoverBorder\",\n};\n","// Leaving this require here. The path-to-regexp module has a commonJS version and an ESM one.\n// We are loading the correct one with the typings with our compilerOptions property \"moduleResolution\" set to \"node\". Ref: https://stackoverflow.com/questions/59013618/unable-to-find-module-path-to-regexp\n// All solutions from closed issues on their repo have been tried. Ref: https://github.com/pillarjs/path-to-regexp/issues/193\n\nimport { matchPath } from \"react-router\";\n\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst { match } = require(\"path-to-regexp\");\n\n// Regex to extract the id from the URL path which supports both the formats:\n// 1. With Mongo ObjectIds\n// 2. With UUID\nconst MONGO_OBJECT_ID_REGEX = \"[0-9a-f]{24}\";\nconst UUID_REGEX =\n  \"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\";\n\nexport const ID_EXTRACTION_REGEX = `(${MONGO_OBJECT_ID_REGEX}|${UUID_REGEX})`;\n\nexport const BUILDER_BASE_PATH_DEPRECATED = \"/applications\";\nexport const BUILDER_VIEWER_PATH_PREFIX = \"/app/\";\nexport const BUILDER_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const BUILDER_CUSTOM_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:customSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const VIEWER_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}`;\nexport const VIEWER_CUSTOM_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:customSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}`;\nexport const getViewerPath = (\n  applicationSlug: string,\n  pageSlug: string,\n  basePageId: string,\n) =>\n  `${BUILDER_VIEWER_PATH_PREFIX}${applicationSlug}/${pageSlug}-${basePageId}`;\nexport const getViewerCustomPath = (customSlug: string, basePageId: string) =>\n  `${BUILDER_VIEWER_PATH_PREFIX}${customSlug}-${basePageId}`;\nexport const BUILDER_PATH_DEPRECATED = `/applications/:baseApplicationId${ID_EXTRACTION_REGEX}/pages/:basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const VIEWER_PATH_DEPRECATED = `/applications/:baseApplicationId${ID_EXTRACTION_REGEX}/pages/:basePageId${ID_EXTRACTION_REGEX}`;\nexport const VIEWER_PATH_DEPRECATED_REGEX =\n  /\\/applications\\/[^/]+\\/pages\\/[^/]+/;\n\nexport const VIEWER_FORK_PATH = `/fork`;\nexport const INTEGRATION_EDITOR_PATH = `/datasources/:selectedTab`;\n\nexport const WIDGETS_EDITOR_BASE_PATH = `/widgets`;\nexport const WIDGETS_EDITOR_ID_PATH = `${WIDGETS_EDITOR_BASE_PATH}/:widgetIds`;\n\n/*\n * CUSTOM WIDGET BUILDER PATHS\n */\nexport const CUSTOM_WIDGETS_EDITOR_ID_PATH = `${BUILDER_PATH}${WIDGETS_EDITOR_ID_PATH}/builder`;\nexport const CUSTOM_WIDGETS_EDITOR_ID_PATH_CUSTOM = `${BUILDER_CUSTOM_PATH}${WIDGETS_EDITOR_ID_PATH}/builder`;\nexport const CUSTOM_WIDGETS_DEPRECATED_EDITOR_ID_PATH = `${BUILDER_PATH_DEPRECATED}${WIDGETS_EDITOR_ID_PATH}/builder`;\n/* */\n\nexport const API_EDITOR_BASE_PATH = `/api`;\nexport const API_EDITOR_ID_PATH = `${API_EDITOR_BASE_PATH}/:baseApiId`;\nexport const API_EDITOR_ID_ADD_PATH = `${API_EDITOR_BASE_PATH}/:baseApiId/add`;\nexport const API_EDITOR_PATH_WITH_SELECTED_PAGE_ID = `${API_EDITOR_BASE_PATH}?importTo=:importTo`;\nexport const QUERIES_EDITOR_BASE_PATH = `/queries`;\nexport const ADD_PATH = `/add`;\nexport const LIST_PATH = \"/list\";\n\nexport const ENTITY_PATH = \"/:entity\";\nexport const QUERIES_EDITOR_ID_PATH = `${QUERIES_EDITOR_BASE_PATH}/:baseQueryId`;\nexport const QUERIES_EDITOR_ADD_PATH = `${QUERIES_EDITOR_BASE_PATH}${ADD_PATH}`;\nexport const QUERIES_EDITOR_ID_ADD_PATH = `${QUERIES_EDITOR_BASE_PATH}/:baseQueryId/add`;\nexport const JS_COLLECTION_EDITOR_PATH = `/jsObjects`;\nexport const JS_COLLECTION_ID_PATH = `${JS_COLLECTION_EDITOR_PATH}/:baseCollectionId`;\nexport const JS_COLLECTION_ID_ADD_PATH = `${JS_COLLECTION_EDITOR_PATH}/:baseCollectionId/add`;\nexport const DATA_SOURCES_EDITOR_LIST_PATH = `/datasource`;\nexport const DATA_SOURCES_EDITOR_ID_PATH = `/datasource/:datasourceId`;\nexport const APP_LIBRARIES_EDITOR_PATH = `/libraries`;\nexport const APP_PACKAGES_EDITOR_PATH = `/packages`;\nexport const APP_SETTINGS_EDITOR_PATH = `/settings`;\nexport const SAAS_GSHEET_EDITOR_ID_PATH = `/saas/google-sheets-plugin/datasources/:datasourceId`;\nexport const BUILDER_CHECKLIST_PATH = `/checklist`;\nexport const ADMIN_SETTINGS_PATH = \"/settings\";\nexport const ADMIN_SETTINGS_CATEGORY_DEFAULT_PATH = \"/settings/general\";\nexport const ADMIN_SETTINGS_CATEGORY_ACL_PATH = \"/settings/groups\";\nexport const ADMIN_SETTINGS_CATEGORY_AUDIT_LOGS_PATH = \"/settings/audit-logs\";\nexport const ADMIN_SETTINGS_CATEGORY_PATH = \"/settings/:category/:selected?\";\nexport const BUILDER_PATCH_PATH = `/:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const VIEWER_PATCH_PATH = `/:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}`;\n\nexport const matchApiBasePath = match(API_EDITOR_BASE_PATH);\nexport const matchApiPath = match(API_EDITOR_ID_PATH);\nexport const matchDatasourcePath = (pathname: string) =>\n  matchPath(pathname, {\n    path: [`${BUILDER_PATH}${DATA_SOURCES_EDITOR_ID_PATH}`],\n    strict: false,\n    exact: false,\n  });\n\nexport const matchSAASGsheetsPath = (pathname: string) =>\n  matchPath(pathname, {\n    path: [`${BUILDER_PATH}${SAAS_GSHEET_EDITOR_ID_PATH}`],\n    strict: false,\n    exact: false,\n  });\nexport const matchQueryBasePath = match(QUERIES_EDITOR_BASE_PATH);\nexport const matchQueryPath = match(QUERIES_EDITOR_ID_PATH);\nexport const matchQueryBuilderPath = match(\n  BUILDER_PATH + QUERIES_EDITOR_ID_PATH,\n);\nexport const matchBuilderPath = (\n  pathName: string,\n  options?: { end?: boolean },\n) =>\n  match(BUILDER_PATH, options)(pathName) ||\n  match(BUILDER_PATH_DEPRECATED, options)(pathName) ||\n  match(BUILDER_CUSTOM_PATH, options)(pathName) ||\n  match(BUILDER_PATH + WIDGETS_EDITOR_ID_PATH, options)(pathName) ||\n  match(BUILDER_CUSTOM_PATH + WIDGETS_EDITOR_ID_PATH, options)(pathName) ||\n  match(BUILDER_PATH_DEPRECATED + WIDGETS_EDITOR_ID_PATH, options)(pathName) ||\n  match(BUILDER_PATH + WIDGETS_EDITOR_ID_PATH + ADD_PATH, options)(pathName);\n\nexport const matchJSObjectPath = match(JS_COLLECTION_ID_PATH);\nexport const matchViewerPath = (pathName: string) =>\n  match(VIEWER_PATH)(pathName) ||\n  match(VIEWER_PATH_DEPRECATED)(pathName) ||\n  match(VIEWER_CUSTOM_PATH)(pathName);\nexport const matchViewerForkPath = (pathName: string) =>\n  match(`${VIEWER_PATH}${VIEWER_FORK_PATH}`)(pathName) ||\n  match(`${VIEWER_CUSTOM_PATH}${VIEWER_FORK_PATH}`)(pathName) ||\n  match(`${VIEWER_PATH_DEPRECATED}${VIEWER_FORK_PATH}`)(pathName);\n\nexport const matchAppLibrariesPath = (pathName: string) =>\n  match(`${BUILDER_PATH}${APP_LIBRARIES_EDITOR_PATH}`)(pathName);\n\nexport const matchAppPackagesPath = (pathName: string) =>\n  match(`${BUILDER_PATH}${APP_PACKAGES_EDITOR_PATH}`)(pathName);\n\nexport const addBranchParam = (branch: string) => {\n  const url = new URL(window.location.href);\n\n  url.searchParams.set(GIT_BRANCH_QUERY_KEY, encodeURIComponent(branch));\n\n  return url.toString().slice(url.origin.length);\n};\n\nexport interface BuilderRouteParams {\n  basePageId: string;\n  baseApplicationId: string;\n}\n\nexport interface AppViewerRouteParams {\n  basePageId: string;\n  baseApplicationId?: string;\n}\n\nexport interface APIEditorRouteParams {\n  basePageId: string;\n  baseApiId?: string;\n}\n\nexport interface QueryEditorRouteParams {\n  basePageId: string;\n  baseQueryId?: string;\n  baseApiId?: string;\n}\n\nexport interface JSEditorRouteParams {\n  basePageId: string;\n  baseCollectionId?: string;\n}\n\nexport const GIT_BRANCH_QUERY_KEY = \"branch\";\n\nexport const INTEGRATION_TABS = {\n  ACTIVE: \"ACTIVE\",\n  NEW: \"NEW\",\n};\n\nexport const INTEGRATION_EDITOR_MODES = {\n  AUTO: \"auto\",\n  MOCK: \"mock\",\n};\n\nexport const PLACEHOLDER_APP_SLUG = \"application\";\nexport const PLACEHOLDER_PAGE_ID = \"basePageId\";\nexport const PLACEHOLDER_PAGE_SLUG = \"page\";\n\nexport const SHOW_FILE_PICKER_KEY = \"showPicker\";\nexport const RESPONSE_STATUS = \"response_status\";\n\nexport const basePathForActiveAction = [BUILDER_PATH, BUILDER_PATH_DEPRECATED];\n","import { difference } from \"lodash\";\nimport { isChildPropertyPath } from \"utils/DynamicBindingUtils\";\nimport { sort } from \"fast-sort\";\n\nexport type TDependencies = Map<string, Set<string>>;\nexport default class DependencyMap {\n  #nodes: Map<string, true>;\n  #dependencies: TDependencies;\n  #dependenciesInverse: TDependencies;\n  #invalidDependencies: TDependencies;\n  #invalidDependenciesInverse: TDependencies;\n\n  constructor() {\n    this.#nodes = new Map();\n    this.#dependencies = new Map();\n    this.#invalidDependencies = new Map();\n    this.#dependenciesInverse = new Map();\n    this.#invalidDependenciesInverse = new Map();\n  }\n\n  // Returns all nodes in the graph\n  get nodes() {\n    return Object.fromEntries(this.#nodes);\n  }\n\n  // Returns all edges in the graph\n  get dependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#dependencies.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  get inverseDependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#dependenciesInverse.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  get invalidDependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#invalidDependencies.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  get inverseInvalidDependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#invalidDependenciesInverse.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  /**\n   * Adds new dependencies to the graph.\n   * Iterates over the dependencies and adds them to the graph if they it is a valid node.\n   * If the dependency is not a valid node, it is added to the invalid dependencies and inverse invalid dependency.\n   * @param node\n   * @param dependencies\n   */\n  public addDependency = (node: string, dependencies: string[]) => {\n    // Only add dependencies for nodes present in the graph\n    if (!this.#nodes.has(node)) return;\n\n    const validDependencies = new Set<string>();\n    const invalidDependencies = new Set<string>();\n\n    // Update the validDependencies and invalidDependencies\n    // Valid dependencies are dependencies present in this.#node, otherwise, they are invalid.\n    for (const dependency of dependencies) {\n      if (this.#nodes.has(dependency)) {\n        validDependencies.add(dependency);\n\n        if (this.#dependenciesInverse.has(dependency)) {\n          this.#dependenciesInverse.get(dependency)?.add(node);\n        } else {\n          this.#dependenciesInverse.set(dependency, new Set([node]));\n        }\n      } else {\n        invalidDependencies.add(dependency);\n\n        if (this.#invalidDependenciesInverse.has(dependency)) {\n          this.#invalidDependenciesInverse.get(dependency)?.add(node);\n        } else {\n          this.#invalidDependenciesInverse.set(dependency, new Set([node]));\n        }\n      }\n    }\n\n    // Now that we have created a new set of dependencies, and invalid dependencies for the node,\n    // we need to remove the node from the inverse-dependencies of previous invalidDeps and validDeps, which have been removed.\n\n    const previousNodeDependencies =\n      this.#dependencies.get(node) || new Set<string>();\n    const newNodeDependencies = validDependencies;\n\n    // dependencies removed from path\n    const removedNodeDependencies = difference(\n      Array.from(previousNodeDependencies),\n      Array.from(newNodeDependencies),\n    );\n\n    // Remove node from the inverseDependencies of removed deps\n    for (const removedDependency of removedNodeDependencies) {\n      this.#dependenciesInverse.get(removedDependency)?.delete(node);\n    }\n\n    const previousNodeInvalidDependencies =\n      this.#invalidDependencies.get(node) || new Set<string>();\n    const newNodeInvalidDependencies = invalidDependencies;\n\n    // invalid dependencies removed from path\n    const removedNodeInvalidDependencies = difference(\n      Array.from(previousNodeInvalidDependencies),\n      Array.from(newNodeInvalidDependencies),\n    );\n\n    // Remove node from the inverseDependencies of removed invalidDeps\n    for (const removedInvalidDependency of removedNodeInvalidDependencies) {\n      this.#invalidDependenciesInverse\n        .get(removedInvalidDependency)\n        ?.delete(node);\n    }\n\n    // Now set the new deps and invalidDeps\n    this.#dependencies.set(node, validDependencies);\n    this.#invalidDependencies.set(node, invalidDependencies);\n  };\n\n  private removeDependency = (node: string) => {\n    let didUpdateDependencies = false;\n    const directDependenciesOfNode = this.getDirectDependencies(node);\n\n    for (const directDependency of directDependenciesOfNode) {\n      this.#dependenciesInverse.get(directDependency)?.delete(node);\n      didUpdateDependencies = true;\n    }\n\n    const nodeExistedInDependencies = this.#dependencies.delete(node);\n\n    if (nodeExistedInDependencies) {\n      didUpdateDependencies = true;\n    }\n\n    this.#invalidDependencies.delete(node);\n\n    return didUpdateDependencies;\n  };\n\n  /**\n   * Adds new nodes to the graph. Should be called when a new node is added to the graph.\n   * Iterates over the nodes and checks in the invalid dependency map, to see if it was used earlier.\n   * If it was used earlier, it is added to the valid dependencies and removed from the invalid dependencies.\n   * @param nodes\n   */\n\n  addNodes = (nodes: Record<string, true>, strict = true) => {\n    const nodesToAdd = strict\n      ? Object.keys(nodes)\n      : sort(Object.keys(nodes)).desc((node) => node.split(\".\").length);\n\n    let didUpdateGraph = false;\n\n    for (const newNode of nodesToAdd) {\n      if (this.#nodes.has(newNode)) continue;\n\n      // New node introduced to the graph.\n      this.#nodes.set(newNode, true);\n      // Check the paths that consumed this node before it was introduced.\n      const nodesThatAlreadyDependedOnThis =\n        this.#invalidDependenciesInverse.get(newNode) || new Set<string>();\n\n      if (!strict) {\n        // In non-strict mode, when the newly added path is a parent of an invalid node,\n        // all paths depending on the invalid node should be added as paths depending on new path\n        // Example => if Button1.text depends on Api1.data.invalidNode(which doesn't exist), if Api1.data is newly added,\n        // then Button1.text should be added to paths that depend on Api1.data\n\n        for (const [invalidNode, dependants] of this\n          .#invalidDependenciesInverse) {\n          if (\n            !nodes.hasOwnProperty(invalidNode) &&\n            isChildPropertyPath(newNode, invalidNode, true)\n          ) {\n            dependants.forEach((dependant) => {\n              nodesThatAlreadyDependedOnThis.add(dependant);\n              this.#invalidDependencies.get(dependant)?.delete(invalidNode);\n            });\n            this.#invalidDependenciesInverse.delete(invalidNode);\n          }\n        }\n      }\n\n      for (const iNode of nodesThatAlreadyDependedOnThis) {\n        // since the invalid node is now valid, add it to the valid dependencies.\n        this.#dependencies.get(iNode)?.add(newNode);\n        this.#invalidDependencies.get(iNode)?.delete(newNode);\n        didUpdateGraph = true;\n\n        if (this.#dependenciesInverse.has(newNode)) {\n          this.#dependenciesInverse.get(newNode)?.add(iNode);\n        } else {\n          this.#dependenciesInverse.set(newNode, new Set([iNode]));\n        }\n      }\n\n      this.#invalidDependenciesInverse.delete(newNode);\n    }\n\n    return didUpdateGraph;\n  };\n\n  removeNodes = (nodes: Record<string, true>) => {\n    let didUpdateDependencies = false;\n\n    for (const node of Object.keys(nodes)) {\n      if (!this.#nodes.has(node)) continue;\n\n      // Remove node from the graph.\n      this.#nodes.delete(node);\n      // Check the paths that consumed this node before it was removed.\n      const nodesThatAlreadyDependedOnThis =\n        this.#dependenciesInverse.get(node) || [];\n\n      for (const iNode of nodesThatAlreadyDependedOnThis) {\n        // since the valid node is now invalid, add it to the invalid dependencies.\n        this.#invalidDependencies.get(iNode)?.add(node);\n        this.#dependencies.get(iNode)?.delete(node);\n        didUpdateDependencies = true;\n\n        if (!this.#nodes.has(iNode)) continue;\n\n        if (this.#invalidDependenciesInverse.has(node)) {\n          this.#invalidDependenciesInverse.get(node)?.add(iNode);\n        } else {\n          this.#invalidDependenciesInverse.set(node, new Set([iNode]));\n        }\n      }\n\n      this.#dependenciesInverse.delete(node);\n      const nodeExistedInDependencies = this.removeDependency(node);\n\n      if (nodeExistedInDependencies) didUpdateDependencies = true;\n    }\n\n    return didUpdateDependencies;\n  };\n\n  isRelated = (source: string, targets: string[]) => {\n    if (targets.includes(source)) return true;\n\n    const visited = new Set();\n    const queue = [source];\n\n    while (queue.length) {\n      const node = queue.shift() as string;\n\n      if (visited.has(node)) continue;\n\n      visited.add(node);\n\n      if (targets.includes(node)) return true;\n\n      const nodes = this.#dependencies.get(node) || [];\n\n      for (const n of nodes) {\n        queue.push(n);\n      }\n    }\n\n    return false;\n  };\n\n  getDependents(node: string) {\n    const nodes = this.#dependenciesInverse.get(node);\n\n    return Array.from(nodes || []);\n  }\n  getDirectDependencies(node: string) {\n    const nodes = this.#dependencies.get(node);\n\n    return Array.from(nodes || []);\n  }\n\n  getAllReachableNodes(source: string, targets: string[]) {\n    const reachableNodes: string[] = [];\n\n    if (targets.includes(source)) reachableNodes.push(source);\n\n    const visited = new Set();\n    const queue = [source];\n\n    while (queue.length) {\n      const node = queue.shift() as string;\n\n      if (visited.has(node)) continue;\n\n      visited.add(node);\n\n      if (targets.includes(node)) reachableNodes.push(node);\n\n      const nodes = this.#dependencies.get(node) || [];\n\n      for (const n of nodes) {\n        queue.push(n);\n      }\n    }\n\n    return reachableNodes;\n  }\n  get rawDependencies() {\n    return this.#dependencies;\n  }\n}\n","import _ from \"./lodash-wrapper\";\nimport moment from \"moment-timezone\";\nimport forge from \"node-forge\";\nimport { defaultLibraries, JSLibraryAccessor } from \"./index\";\nimport { JSLibraries, libraryReservedIdentifiers } from \"./index\";\nimport { invalidEntityIdentifiers } from \"../DependencyMap/utils\";\nconst defaultLibImplementations = {\n  lodash: _,\n  moment: moment,\n  // We are removing some functionalities of node-forge because they wont\n  // work in the worker thread\n  forge: /*#__PURE*/ _.omit(forge, [\"tls\", \"http\", \"xhr\", \"socket\", \"task\"]),\n};\n\nexport function resetJSLibraries() {\n  JSLibraries.length = 0;\n  JSLibraries.push(...defaultLibraries);\n  const defaultLibraryAccessors = defaultLibraries.map(\n    (lib) => lib.accessor[0],\n  );\n\n  for (const key of Object.keys(libraryReservedIdentifiers)) {\n    if (defaultLibraryAccessors.includes(key)) continue;\n\n    try {\n      // @ts-expect-error: Types are not available\n      delete self[key];\n    } catch (e) {\n      // @ts-expect-error: Types are not available\n      self[key] = undefined;\n    }\n    //we have to update invalidEntityIdentifiers as well\n    delete libraryReservedIdentifiers[key];\n    delete invalidEntityIdentifiers[key];\n  }\n\n  JSLibraries.forEach((library) => {\n    if (!(library.name in defaultLibImplementations))\n      throw new Error(\n        `resetJSLibraries(): implementation for library ${library.name} not found. Have you forgotten to add it to the defaultLibrariesImpls object?`,\n      );\n\n    // @ts-expect-error: Types are not available\n    self[library.accessor] = defaultLibImplementations[library.name];\n  });\n  JSLibraryAccessor.regenerateSet();\n}\n","import log from \"loglevel\";\nimport type { Def } from \"tern\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getTernDocType(obj: any) {\n  const type = typeof obj;\n\n  switch (type) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n      return \"number\";\n    case \"boolean\":\n      return \"bool\";\n    case \"undefined\":\n      return \"?\";\n    case \"function\":\n      return \"fn()\";\n    default:\n      return \"?\";\n  }\n}\n\nexport function typeToTernType(type: string) {\n  if (type === \"boolean\") return \"bool\";\n\n  if (type === \"function\") return \"fn()\";\n\n  if (type === \"number\") return \"number\";\n\n  if (type === \"array\") return \"[]\";\n\n  if (type === \"string\") return \"string\";\n\n  return \"?\";\n}\n\nconst ignoredKeys = [\n  \"constructor\",\n  \"WINDOW\",\n  \"window\",\n  \"self\",\n  \"arguments\",\n  \"caller\",\n  \"length\",\n  \"name\",\n];\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function makeTernDefs(obj: any) {\n  const defs: Def = {};\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const cachedDefs: any = [];\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const visitedReferences: any = [];\n  const MAX_ITERATIONS = 5000;\n  let iteration_count = 1;\n  const baseObjPrototype = Object.getPrototypeOf({});\n\n  const queue = [[obj, defs]];\n\n  try {\n    while (queue.length && iteration_count < MAX_ITERATIONS) {\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const [src, target] = queue.shift() as any;\n\n      if (visitedReferences.includes(src)) {\n        target[\"!type\"] = cachedDefs[visitedReferences.indexOf(src)][\"!type\"];\n        continue;\n      }\n\n      const type = typeof src;\n\n      if (!src || (type !== \"object\" && type !== \"function\")) {\n        target[\"!type\"] = getTernDocType(src);\n        continue;\n      } else if (type === \"function\") {\n        target[\"!type\"] = \"fn()\";\n      }\n\n      queue.push(\n        ...Object.getOwnPropertyNames(src)\n          .filter((key) => !ignoredKeys.includes(key))\n          .map((key) => {\n            target[key] = {};\n\n            return [src[key], target[key]];\n          }),\n      );\n\n      if (type === \"object\") {\n        const prototype = Object.getPrototypeOf(src);\n\n        if (prototype !== baseObjPrototype) {\n          queue.push(\n            ...Object.getOwnPropertyNames(prototype)\n              .filter((key) => !ignoredKeys.includes(key))\n              .map((key) => {\n                target[key] = {};\n\n                return [src[key], target[key]];\n              }),\n          );\n        }\n      }\n\n      iteration_count++;\n    }\n  } catch (e) {\n    log.debug(\"Unknown depth\", e);\n  }\n\n  return defs;\n}\n","import difference from \"lodash/difference\";\nimport type { Def } from \"tern\";\nimport { invalidEntityIdentifiers } from \"workers/common/DependencyMap/utils\";\nimport {\n  JSLibraries,\n  JSLibraryAccessor,\n  libraryReservedIdentifiers,\n} from \"../../common/JSLibrary\";\nimport type { JSLibrary } from \"../../common/JSLibrary\";\nimport { resetJSLibraries } from \"../../common/JSLibrary/resetJSLibraries\";\nimport { makeTernDefs } from \"../../common/JSLibrary/ternDefinitionGenerator\";\nimport type { EvalWorkerASyncRequest, EvalWorkerSyncRequest } from \"../types\";\nimport { dataTreeEvaluator } from \"./evalTree\";\nimport log from \"loglevel\";\n\ndeclare global {\n  interface WorkerGlobalScope {\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [x: string]: any;\n  }\n}\n\ndeclare const self: WorkerGlobalScope;\n\nenum LibraryInstallError {\n  NameCollisionError,\n  ImportError,\n  TernDefinitionError,\n  LibraryOverrideError,\n}\n\nclass ImportError extends Error {\n  code = LibraryInstallError.ImportError;\n  constructor(url: string) {\n    super(`The script at ${url} cannot be installed.`);\n    this.name = \"ImportError\";\n  }\n}\n\nclass TernDefinitionError extends Error {\n  code = LibraryInstallError.TernDefinitionError;\n  constructor(name: string) {\n    super(`Failed to generate autocomplete definitions for ${name}.`);\n    this.name = \"TernDefinitionError\";\n  }\n}\n\nconst removeDataTreeFromContext = () => {\n  if (!dataTreeEvaluator) return {};\n\n  const evalTree = dataTreeEvaluator?.getEvalTree();\n  const dataTreeEntityNames = Object.keys(evalTree);\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const tempDataTreeStore: Record<string, any> = {};\n\n  for (const entityName of dataTreeEntityNames) {\n    tempDataTreeStore[entityName] = self[entityName];\n    delete self[entityName];\n  }\n\n  return tempDataTreeStore;\n};\n\nfunction addTempStoredDataTreeToContext(\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  tempDataTreeStore: Record<string, any>,\n) {\n  const dataTreeEntityNames = Object.keys(tempDataTreeStore);\n\n  for (const entityName of dataTreeEntityNames) {\n    self[entityName] = tempDataTreeStore[entityName];\n  }\n}\n\nexport async function installLibrary(\n  request: EvalWorkerASyncRequest<{\n    url: string;\n    takenNamesMap: Record<string, true>;\n    takenAccessors: Array<string>;\n  }>,\n) {\n  const { data } = request;\n  const { takenAccessors, takenNamesMap, url } = data;\n  const defs: Def = {};\n  /**\n   * We need to remove the data tree from the global scope before importing the library.\n   * This is because the library might have a variable with the same name as a data tree entity. If that happens, the data tree entity will be overridden by the library variable.\n   * We store the data tree in a temporary variable and add it back to the global scope after the library is imported.\n   */\n  const tempDataTreeStore = removeDataTreeFromContext();\n\n  // Map of all the currently installed libraries\n  const libStore = takenAccessors.reduce(\n    (acc: Record<string, unknown>, a: string) => {\n      acc[a] = self[a];\n\n      return acc;\n    },\n    {},\n  );\n\n  try {\n    const envKeysBeforeInstallation = Object.keys(self);\n\n    /** Holds keys of uninstalled libraries that cannot be removed from worker global.\n     * Certain libraries are added to the global scope with { configurable: false }\n     */\n    const unsetLibraryKeys = envKeysBeforeInstallation.filter(\n      (k) => self[k] === undefined,\n    );\n\n    const accessors: string[] = [];\n\n    let module = null;\n\n    try {\n      /**\n       * Try to import the library using importScripts\n       * This works for UMD modules\n       * If this fails, we try to import the library using dynamic import\n       */\n      self.importScripts(url);\n\n      // Find keys add that were installed to the global scope.\n      const keysAfterInstallation = Object.keys(self);\n\n      let differentiatingKeys = difference(\n        keysAfterInstallation,\n        envKeysBeforeInstallation,\n      );\n\n      // Changing default export to library specific name, if default exported\n      const uniqueName = generateUniqueAccessor(\n        url,\n        takenAccessors,\n        takenNamesMap,\n      );\n\n      movetheDefaultExportedLibraryToAccessorKey(\n        differentiatingKeys,\n        uniqueName,\n      );\n\n      // Following the same process which was happening earlier\n      const keysAfterDefaultOperation = Object.keys(self);\n\n      differentiatingKeys = difference(\n        keysAfterDefaultOperation,\n        envKeysBeforeInstallation,\n      );\n      accessors.push(...differentiatingKeys);\n\n      /**\n       * Check the list of installed library to see if their values have changed.\n       * This is to check if the newly installed library overwrites an already existing one\n       * For eg. let's say lodash v1 and v2 both have the same accessor `_`.\n       * If lodash v1 is installed first, `_` will be added to the global scope.\n       * This value is stored in libStore. ie libStore['_'] = lodash v1\n       * Now when lodash v2 is installed, `_` will be added to the global scope again.\n       * We check if the value of `_` has changed to detect this. ie . libStore['_'] !== lodash v2\n       * If it has changed, we add the new value to the global scope with a unique name.\n       * */\n      accessors.push(\n        ...Object.keys(libStore).filter((k) => {\n          return libStore[k] !== self[k];\n        }),\n      );\n\n      /**\n       * Certain libraries are added to the global scope with { configurable: false }\n       * These libraries cannot be removed from the global scope via delete operation so we set them to undefined them during uninstall request.\n       * These library accessors are removed from takenAccessors list.\n       * So they will remain in the global scope even after uninstallation. self[accessor] = undefined.\n       * Any attempt to reinstall the same library will overwrite the library with undefined and we need to detect these accessors.\n       */\n      accessors.push(...unsetLibraryKeys.filter((k) => self[k] !== undefined));\n\n      // Generate unique names for accessors that are already taken.\n      for (let i = 0; i < accessors.length; i++) {\n        if (\n          takenNamesMap.hasOwnProperty(accessors[i]) ||\n          takenAccessors.includes(accessors[i])\n        ) {\n          const uniqueName = generateUniqueAccessor(\n            accessors[i],\n            takenAccessors,\n            takenNamesMap,\n          );\n\n          self[uniqueName] = self[accessors[i]];\n          accessors[i] = uniqueName;\n        }\n      }\n    } catch (e) {\n      log.debug(e, `importScripts failed for ${url}`);\n      try {\n        // If importScripts fails, try to import the library using dynamic import\n        module = await import(/* webpackIgnore: true */ url);\n\n        // If the module is not an object, it is not a valid ESM library\n        if (module && typeof module === \"object\") {\n          const uniqAccessor = generateUniqueAccessor(\n            url,\n            takenAccessors,\n            takenNamesMap,\n          );\n\n          self[uniqAccessor] = flattenModule(module);\n          accessors.push(uniqAccessor);\n        }\n      } catch (e) {\n        log.debug(e, `dynamic import failed for ${url}`);\n        throw new ImportError(url);\n      }\n    }\n\n    // If no accessors at this point, installation likely failed.\n    if (accessors.length === 0) {\n      throw new Error(\"Unable to determine a unique accessor\");\n    }\n\n    // Name of the library is the last accessor. This is totally random and needs fixing.\n    const name = accessors[accessors.length - 1];\n\n    defs[\"!name\"] = `LIB/${name}`;\n    try {\n      for (const key of accessors) {\n        defs[key] = makeTernDefs(self[key]);\n      }\n    } catch (e) {\n      for (const acc of accessors) {\n        self[acc] = undefined;\n      }\n\n      log.debug(e, `ternDefinitions failed for ${url}`);\n      throw new TernDefinitionError(\n        `Failed to generate autocomplete definitions: ${name}`,\n      );\n    }\n\n    // Restore the libraries from libStore to the global scope.\n    // This is done to ensure that the libraries are not overwritten by the newly installed library.\n    Object.keys(libStore).forEach((k) => (self[k] = libStore[k]));\n\n    //Reserve accessor names.\n    for (const acc of accessors) {\n      //we have to update invalidEntityIdentifiers as well\n      libraryReservedIdentifiers[acc] = true;\n      invalidEntityIdentifiers[acc] = true;\n    }\n\n    return { success: true, defs, accessor: accessors };\n  } catch (error) {\n    addTempStoredDataTreeToContext(tempDataTreeStore);\n    takenAccessors.forEach((k) => (self[k] = libStore[k]));\n\n    return { success: false, defs, error };\n  }\n}\n\nexport function uninstallLibrary(\n  request: EvalWorkerSyncRequest<Array<string>>,\n) {\n  const { data } = request;\n  const accessor = data;\n\n  try {\n    for (const key of accessor) {\n      self[key] = undefined;\n      //we have to update invalidEntityIdentifiers as well\n      delete libraryReservedIdentifiers[key];\n      delete invalidEntityIdentifiers[key];\n    }\n\n    return { success: true };\n  } catch (e) {\n    return { success: false };\n  }\n}\n\nexport async function loadLibraries(\n  request: EvalWorkerASyncRequest<JSLibrary[]>,\n) {\n  resetJSLibraries();\n  const { data: libs } = request;\n  let message = \"\";\n  const libStore: Record<string, unknown> = {};\n\n  try {\n    for (const lib of libs) {\n      const url = lib.url as string;\n      const accessors = lib.accessor;\n      const keysBefore = Object.keys(self);\n      let module = null;\n\n      try {\n        self.importScripts(url);\n        const keysAfter = Object.keys(self);\n        let defaultAccessors = difference(keysAfter, keysBefore);\n\n        // Changing default export to library accessors name which was saved when it was installed, if default export present\n        movetheDefaultExportedLibraryToAccessorKey(\n          defaultAccessors,\n          accessors[0],\n        );\n\n        // Following the same process which was happening earlier\n        const keysAfterDefaultOperation = Object.keys(self);\n\n        defaultAccessors = difference(keysAfterDefaultOperation, keysBefore);\n\n        /**\n         * Installing 2 different version of lodash tries to add the same accessor on the self object. Let take version a & b for example.\n         * Installation of version a, will add _ to the self object and can be detected by looking at the differences in the previous step.\n         * Now when version b is installed, differences will be [], since _ already exists in the self object.\n         * We add all the installations to the libStore and see if the reference it points to in the self object changes.\n         * If the references changes it means that it a valid accessor.\n         */\n        defaultAccessors.push(\n          ...Object.keys(libStore).filter((k) => libStore[k] !== self[k]),\n        );\n\n        /**\n         * Sort the accessor list from backend and installed accessor list using the same rule to apply all modifications.\n         * This is required only for UMD builds, since we always generate unique names for ESM.\n         */\n        accessors.sort();\n        defaultAccessors.sort();\n\n        for (let i = 0; i < defaultAccessors.length; i++) {\n          self[accessors[i]] = self[defaultAccessors[i]];\n          libStore[defaultAccessors[i]] = self[defaultAccessors[i]];\n          libraryReservedIdentifiers[accessors[i]] = true;\n          invalidEntityIdentifiers[accessors[i]] = true;\n        }\n\n        continue;\n      } catch (e) {\n        log.debug(e);\n      }\n\n      try {\n        module = await import(/* webpackIgnore: true */ url);\n\n        if (!module || typeof module !== \"object\") throw \"Not an ESM module\";\n\n        const key = accessors[0];\n        const flattenedModule = flattenModule(module);\n\n        libStore[key] = flattenedModule;\n        self[key] = flattenedModule;\n        libraryReservedIdentifiers[key] = true;\n        invalidEntityIdentifiers[key] = true;\n      } catch (e) {\n        log.debug(e);\n        throw new ImportError(url);\n      }\n    }\n\n    JSLibraries.push(...libs);\n    JSLibraryAccessor.regenerateSet();\n\n    return { success: true, message };\n  } catch (e) {\n    message = (e as Error).message;\n\n    return { success: false, message };\n  }\n}\n\n/**\n * This function is called only for ESM modules and generates a unique namespace for the module.\n * @param url\n * @param takenAccessors\n * @param takenNamesMap\n * @returns\n */\nfunction generateUniqueAccessor(\n  urlOrName: string,\n  takenAccessors: Array<string>,\n  takenNamesMap: Record<string, true>,\n) {\n  let name = urlOrName;\n\n  // extract file name from url\n  try {\n    // Checks to see if a URL was passed\n    const urlObject = new URL(urlOrName);\n    /**\n     * URL pattern for ESM modules from jsDelivr - https://cdn.jsdelivr.net/npm/stripe@13.3.0/+esm\n     * Assuming the file name is the last part of the path\n     * TODO: Find a better way to extract the file name from the URL\n     * TODO: Handle the case where the URL is from a different CDN like unpkg, cdnjs etc.\n     */\n    const urlPathParts = urlObject.pathname.split(\"/\");\n\n    name = urlPathParts.pop() as string;\n    name = name?.includes(\"+esm\") ? (urlPathParts.pop() as string) : name;\n  } catch (e) {}\n\n  // Replace all non-alphabetic characters with underscores and remove trailing underscores\n  const validVar = name.replace(/[^a-zA-Z]/g, \"_\").replace(/_+$/, \"\");\n\n  if (\n    !takenAccessors.includes(validVar) &&\n    !takenNamesMap.hasOwnProperty(validVar)\n  ) {\n    return validVar;\n  }\n\n  let index = 0;\n\n  /**\n   * If the accessor is already taken, generate a unique name by appending an index to the accessor.\n   * The index is incremented until a unique name is found.\n   * 100 is a very large number and this loop should never run more than a few times.\n   */\n  while (index++ < 100) {\n    const name = `${validVar}_${index}`;\n\n    if (!takenAccessors.includes(name) && !takenNamesMap.hasOwnProperty(name)) {\n      return name;\n    }\n  }\n\n  throw new Error(\"Unable to generate a unique accessor\");\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function flattenModule(module: Record<string, any>) {\n  const keys = Object.keys(module);\n\n  // If there are no keys other than default, return default.\n  if (keys.length === 1 && keys[0] === \"default\") return module.default;\n\n  // If there are keys other than default, return a new object with all the keys\n  // and set its prototype of default export.\n  const libModule = Object.create(module.default || {});\n\n  for (const key of Object.keys(module)) {\n    if (key === \"default\") continue;\n\n    libModule[key] = module[key];\n  }\n\n  return libModule;\n}\n\n// This function will update the self keys only when the diffAccessors has default included in it.\nfunction movetheDefaultExportedLibraryToAccessorKey(\n  diffAccessors: string[],\n  uniqAccessor: string,\n) {\n  if (diffAccessors.length > 0 && diffAccessors.includes(\"default\")) {\n    // mapping default functionality to library name accessor\n    self[uniqAccessor] = self[\"default\"];\n    // deleting the reference of default key from the self object\n    delete self[\"default\"];\n    // mapping all the references of differentiating keys from the self object to the self[uniqAccessor] key object\n    diffAccessors.map((key) => {\n      if (key !== \"default\") {\n        self[uniqAccessor][key] = self[key];\n        // deleting the references from the self object\n        delete self[key];\n      }\n    });\n  }\n}\n","import type { Diff } from \"deep-diff\";\nimport type { Action } from \"entities/Action\";\nimport ReplayEntity from \"..\";\nimport { pathArrayToString } from \"../replayUtils\";\nimport type { JSActionConfig } from \"entities/JSCollection\";\nimport type { Datasource } from \"entities/Datasource\";\nimport type { ENTITY_TYPE } from \"ee/entities/AppsmithConsole/utils\";\nimport isEmpty from \"lodash/isEmpty\";\nimport type { Canvas } from \"./ReplayCanvas\";\n\n/*\n This type represents all the form objects that can be undone/redone.\n (Action, datasource, jsAction etc)\n*/\nexport type Replayable =\n  | Partial<JSActionConfig>\n  | Partial<Datasource>\n  | Partial<Action>\n  | Partial<Canvas>;\n\ntype ReplayEditorDiff = Diff<Replayable, Replayable>;\n\nexport interface ReplayEditorUpdate {\n  modifiedProperty: string;\n  index?: number;\n  update: Replayable | ReplayEditorDiff;\n  kind: \"N\" | \"D\" | \"E\" | \"A\";\n  isUndo?: boolean;\n}\nexport default class ReplayEditor extends ReplayEntity<Replayable> {\n  constructor(entity: Replayable, entityType: ENTITY_TYPE) {\n    super(entity, entityType);\n  }\n\n  public processDiff(\n    diff: Diff<Replayable, Replayable>,\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    replay: any,\n    isUndo: boolean,\n  ): void {\n    if (!diff || !diff.path || !diff.path.length) return;\n\n    replay.updates = (replay.updates || []).concat(\n      this.getChanges(diff, isUndo) || [],\n    );\n  }\n\n  /*\n    The should get us the modified property (configProperty from editor, settings and form json files), the updated value and the kind of update.\n    The modifiedProperty would be used to highlight the field that has been replayed. We might need to use the kind in future to display toast\n    messages or even highlight based on the kind.\n  */\n  private getChanges(\n    diff: Diff<Replayable, Replayable>,\n    isUndo: boolean,\n  ): ReplayEditorUpdate | undefined {\n    const { kind, path } = diff;\n\n    if (diff.kind === \"N\") {\n      if (isEmpty(diff.rhs)) return;\n\n      return {\n        modifiedProperty: pathArrayToString(path),\n        update: diff.rhs,\n        kind,\n      };\n    } else if (diff.kind === \"A\") {\n      return {\n        modifiedProperty: pathArrayToString(path),\n        update: diff.item,\n        index: diff.index,\n        kind,\n        isUndo,\n      };\n    } else if (diff.kind === \"E\") {\n      return {\n        modifiedProperty: pathArrayToString(path),\n        update: isUndo ? diff.lhs : diff.rhs,\n        kind,\n      };\n    }\n\n    return {\n      modifiedProperty: pathArrayToString(path),\n      update: diff.lhs,\n      kind,\n    };\n  }\n}\n","import ExecutionMetaData from \"../utils/ExecutionMetaData\";\n\nconst _internalSetTimeout = self.setTimeout;\nconst _internalClearTimeout = self.clearTimeout;\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setTimeout(cb: (...args: any) => any, delay: number, ...args: any) {\n  const metaData = ExecutionMetaData.getExecutionMetaData();\n\n  return _internalSetTimeout(\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function (...args: any) {\n      self[\"$isDataField\"] = false;\n      ExecutionMetaData.setExecutionMetaData(metaData);\n      typeof cb === \"function\" && cb(...args);\n    },\n    delay,\n    ...args,\n  );\n}\n\nfunction clearTimeout(timerId: number) {\n  return _internalClearTimeout(timerId);\n}\n\nexport { setTimeout, clearTimeout };\n","const _originalFetch = self.fetch;\n\nexport async function fetch(...args: Parameters<typeof _originalFetch>) {\n  const request = new Request(args[0] as string, {\n    ...args[1],\n    credentials: \"omit\",\n  });\n\n  return _originalFetch(request);\n}\n","import get from \"lodash/get\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport default function initLocalStorage(this: any) {\n  const getItem = (key: string) => {\n    return get(this.appsmith.store, key);\n  };\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const setItem = (key: string, value: any) => {\n    this.storeValue(key, value);\n  };\n  const removeItem = (key: string) => {\n    this.removeValue(key);\n  };\n  const clear = () => {\n    this.clearStore();\n  };\n  const localStorage = {\n    getItem,\n    setItem,\n    removeItem,\n    clear,\n  };\n\n  Object.defineProperty(this, \"localStorage\", {\n    enumerable: false,\n    value: localStorage,\n  });\n}\n","import { setInterval, clearInterval } from \"./interval\";\nimport { setTimeout, clearTimeout } from \"./timeout\";\nimport { fetch } from \"./fetch\";\nimport { addFn } from \"../utils/fnGuard\";\nimport userLogs from \"./console\";\nimport initLocalStorage from \"./localStorage\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function overrideWebAPIs(ctx: any) {\n  userLogs.overrideConsoleAPI();\n  addFn(ctx, \"setInterval\", setInterval);\n  addFn(ctx, \"clearInterval\", clearInterval);\n  addFn(ctx, \"setTimeout\", setTimeout);\n  addFn(ctx, \"clearTimeout\", clearTimeout);\n  addFn(ctx, \"fetch\", fetch);\n  initLocalStorage.call(ctx);\n}\n","import noop from \"lodash/noop\";\nimport type {\n  EVAL_WORKER_ASYNC_ACTION,\n  EVAL_WORKER_SYNC_ACTION,\n} from \"ee/workers/Evaluation/evalWorkerActions\";\nimport { EVAL_WORKER_ACTIONS } from \"ee/workers/Evaluation/evalWorkerActions\";\nimport type { EvalWorkerSyncRequest, EvalWorkerASyncRequest } from \"../types\";\nimport evalActionBindings from \"./evalActionBindings\";\nimport evalExpression from \"./evalExpression\";\nimport {\n  evalTree,\n  clearCache,\n  evalTreeTransmissionErrorHandler,\n} from \"./evalTree\";\nimport evalTrigger from \"./evalTrigger\";\nimport initFormEval from \"./initFormEval\";\nimport { installLibrary, loadLibraries, uninstallLibrary } from \"./jsLibrary\";\nimport { redo, undo, updateReplayObject } from \"./replay\";\nimport setupEvaluationEnvironment, {\n  setEvaluationVersion,\n} from \"./setupEvalEnv\";\nimport validateProperty from \"./validateProperty\";\nimport updateActionData from \"./updateActionData\";\nimport type { TransmissionErrorHandler } from \"../fns/utils/Messenger\";\nimport { evalTreeWithChanges } from \"../evalTreeWithChanges\";\n\nconst syncHandlerMap: Record<\n  EVAL_WORKER_SYNC_ACTION,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (req: EvalWorkerSyncRequest) => any\n> = {\n  [EVAL_WORKER_ACTIONS.EVAL_ACTION_BINDINGS]: evalActionBindings,\n  [EVAL_WORKER_ACTIONS.EVAL_TREE_WITH_CHANGES]: evalTreeWithChanges,\n  [EVAL_WORKER_ACTIONS.UNDO]: undo,\n  [EVAL_WORKER_ACTIONS.REDO]: redo,\n  [EVAL_WORKER_ACTIONS.UPDATE_REPLAY_OBJECT]: updateReplayObject,\n  [EVAL_WORKER_ACTIONS.VALIDATE_PROPERTY]: validateProperty,\n  [EVAL_WORKER_ACTIONS.UNINSTALL_LIBRARY]: uninstallLibrary,\n  [EVAL_WORKER_ACTIONS.LINT_TREE]: noop,\n  [EVAL_WORKER_ACTIONS.SETUP]: setupEvaluationEnvironment,\n  [EVAL_WORKER_ACTIONS.CLEAR_CACHE]: clearCache,\n  [EVAL_WORKER_ACTIONS.SET_EVALUATION_VERSION]: setEvaluationVersion,\n  [EVAL_WORKER_ACTIONS.INIT_FORM_EVAL]: initFormEval,\n  [EVAL_WORKER_ACTIONS.UPDATE_ACTION_DATA]: updateActionData,\n};\n\nconst asyncHandlerMap: Record<\n  EVAL_WORKER_ASYNC_ACTION,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (req: EvalWorkerASyncRequest) => any\n> = {\n  [EVAL_WORKER_ACTIONS.EVAL_TREE]: evalTree,\n  [EVAL_WORKER_ACTIONS.EVAL_TRIGGER]: evalTrigger,\n  [EVAL_WORKER_ACTIONS.EVAL_EXPRESSION]: evalExpression,\n  [EVAL_WORKER_ACTIONS.LOAD_LIBRARIES]: loadLibraries,\n  [EVAL_WORKER_ACTIONS.INSTALL_LIBRARY]: installLibrary,\n};\n\nconst transmissionErrorHandlerMap: Partial<\n  Record<\n    EVAL_WORKER_SYNC_ACTION | EVAL_WORKER_ASYNC_ACTION,\n    TransmissionErrorHandler\n  >\n> = {\n  [EVAL_WORKER_ACTIONS.EVAL_TREE]: evalTreeTransmissionErrorHandler,\n};\n\nexport { syncHandlerMap, asyncHandlerMap, transmissionErrorHandlerMap };\n","import { dataTreeEvaluator } from \"./evalTree\";\nimport { removeFunctions } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { EvalWorkerSyncRequest } from \"../types\";\n\nexport default function (request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { bindings, executionParams } = data;\n\n  if (!dataTreeEvaluator) {\n    return { values: undefined, errors: [] };\n  }\n\n  const values = dataTreeEvaluator.evaluateActionBindings(\n    bindings,\n    executionParams,\n  );\n\n  const cleanValues = removeFunctions(values);\n\n  const errors = dataTreeEvaluator.errors;\n\n  dataTreeEvaluator.clearErrors();\n\n  return { values: cleanValues, errors };\n}\n","import ReplayEditor from \"entities/Replay/ReplayEntity/ReplayEditor\";\nimport type { EvalWorkerSyncRequest } from \"../types\";\nimport { CANVAS, replayMap } from \"./evalTree\";\n\nexport function undo(request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { entityId } = data;\n\n  if (!replayMap) return;\n\n  if (!replayMap[entityId || CANVAS]) return;\n\n  const replayResult = replayMap[entityId || CANVAS].replay(\"UNDO\");\n\n  replayMap[entityId || CANVAS].clearLogs();\n\n  return replayResult;\n}\n\nexport function redo(request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { entityId } = data;\n\n  if (!replayMap) return;\n\n  if (!replayMap[entityId ?? CANVAS]) return;\n\n  const replayResult = replayMap[entityId ?? CANVAS].replay(\"REDO\");\n\n  replayMap[entityId ?? CANVAS].clearLogs();\n\n  return replayResult;\n}\n\nexport function updateReplayObject(request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { entity, entityId, entityType } = data;\n\n  if (!replayMap) return false;\n\n  const replayObject = replayMap[entityId];\n\n  if (replayObject) {\n    replayObject.update(entity);\n  } else {\n    replayMap[entityId] = new ReplayEditor(entity, entityType);\n  }\n\n  return true;\n}\n","import { validateWidgetProperty } from \"workers/common/DataTreeEvaluator/validationUtils\";\nimport { removeFunctions } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { EvalWorkerSyncRequest } from \"../types\";\n\nexport default function (request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { property, props, validation, value } = data;\n\n  return removeFunctions(\n    validateWidgetProperty(validation, value, props, property),\n  );\n}\n","import { unsafeFunctionForEval } from \"utils/DynamicBindingUtils\";\nimport setupDOM from \"../SetupDOM\";\nimport type { EvalWorkerSyncRequest } from \"../types\";\nimport { addPlatformFunctionsToEvalContext } from \"ee/workers/Evaluation/Actions\";\nimport { overrideWebAPIs } from \"../fns/overrides\";\nimport { WorkerEnv } from \"./workerEnv\";\n\nexport default function (request: EvalWorkerSyncRequest) {\n  self.$isDataField = false;\n  ///// Remove all unsafe functions\n  unsafeFunctionForEval.forEach((func) => {\n    // @ts-expect-error: Types are not available\n    self[func] = undefined;\n  });\n  setupDOM();\n  overrideWebAPIs(self);\n\n  WorkerEnv.setFeatureFlags(request.data.featureFlags);\n  WorkerEnv.setCloudHosting(request.data.cloudHosting);\n  addPlatformFunctionsToEvalContext(self);\n\n  return true;\n}\n\nexport function setEvaluationVersion(request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { version } = data;\n\n  self.evaluationVersion = version || 1;\n\n  return true;\n}\n","//@ts-expect-error no types.\nimport * as documentMock from \"linkedom/worker\";\n\nexport default function () {\n  for (const [key, value] of Object.entries(documentMock)) {\n    //@ts-expect-error no types\n    self[key] = value;\n  }\n\n  const dom = documentMock.parseHTML(`<!DOCTYPE html><body></body>`);\n\n  self.window = dom.window;\n  self.document = dom.window.document;\n  self.window = self;\n}\n","import { setFormEvaluationSaga } from \"../formEval\";\nimport type { EvalWorkerSyncRequest } from \"../types\";\n\nexport default function (request: EvalWorkerSyncRequest) {\n  const { data } = request;\n  const { currentEvalState, payload, type } = data;\n  const response = setFormEvaluationSaga(type, payload, currentEvalState);\n\n  return response;\n}\n","import { dataTreeEvaluator } from \"./evalTree\";\nimport type { EvalWorkerASyncRequest } from \"../types\";\nimport ExecutionMetaData from \"../fns/utils/ExecutionMetaData\";\nimport { evaluateAndPushResponse } from \"../evalTreeWithChanges\";\n\nexport default async function (request: EvalWorkerASyncRequest) {\n  const { data } = request;\n  const {\n    callbackData,\n    dynamicTrigger,\n    eventType,\n    globalContext,\n    triggerMeta,\n    unEvalTree,\n  } = data;\n\n  if (!dataTreeEvaluator) {\n    return { triggers: [], errors: [] };\n  }\n\n  ExecutionMetaData.setExecutionMetaData({ triggerMeta, eventType });\n\n  if (!triggerMeta.onPageLoad) {\n    const { evalOrder, unEvalUpdates } = dataTreeEvaluator.setupUpdateTree(\n      unEvalTree.unEvalTree,\n      unEvalTree.configTree,\n      undefined,\n      //TODO: the evalTrigger can be optimised to not diff all JS actions\n      { isAllAffected: true, ids: [] },\n    );\n\n    evaluateAndPushResponse(\n      dataTreeEvaluator,\n      { evalOrder, unEvalUpdates, jsUpdates: {} },\n      [],\n      [],\n    );\n  }\n\n  return dataTreeEvaluator.evaluateTriggers(\n    dynamicTrigger,\n    dataTreeEvaluator.getEvalTree(),\n    unEvalTree.configTree,\n    callbackData,\n    {\n      globalContext,\n      eventType,\n      triggerMeta,\n    },\n  );\n}\n","import { klona } from \"klona/full\";\nimport { evaluateAsync } from \"../evaluate\";\nimport type { EvalWorkerASyncRequest } from \"../types\";\nimport { dataTreeEvaluator } from \"./evalTree\";\n\nexport default function (request: EvalWorkerASyncRequest) {\n  const { data } = request;\n  const { expression } = data;\n  const evalTree = dataTreeEvaluator?.evalTree;\n  const configTree = dataTreeEvaluator?.configTree;\n\n  if (!evalTree || !configTree) return {};\n\n  return evaluateAsync(expression, klona(evalTree), configTree, {}, undefined);\n}\n","// Workers do not have access to log.error\n/* eslint-disable no-console */\nimport type { EvalWorkerASyncRequest, EvalWorkerSyncRequest } from \"./types\";\nimport {\n  syncHandlerMap,\n  asyncHandlerMap,\n  transmissionErrorHandlerMap,\n} from \"./handlers\";\nimport type { TMessage } from \"utils/MessageUtil\";\nimport { MessageType } from \"utils/MessageUtil\";\nimport { WorkerMessenger } from \"./fns/utils/Messenger\";\n\n//TODO: Create a more complete RPC setup in the subtree-eval branch.\nfunction syncRequestMessageListener(\n  e: MessageEvent<TMessage<EvalWorkerSyncRequest>>,\n) {\n  const { messageType } = e.data;\n\n  if (messageType !== MessageType.REQUEST) return;\n\n  const startTime = Date.now();\n  const { body, messageId } = e.data;\n  const { method } = body;\n\n  if (!method) return;\n\n  const messageHandler = syncHandlerMap[method];\n\n  if (typeof messageHandler !== \"function\") return;\n\n  const responseData = messageHandler(body);\n  const transmissionErrorHandler = transmissionErrorHandlerMap[method];\n  const endTime = Date.now();\n\n  WorkerMessenger.respond(\n    messageId,\n    responseData,\n    startTime,\n    endTime,\n    transmissionErrorHandler,\n  );\n}\n\nasync function asyncRequestMessageListener(\n  e: MessageEvent<TMessage<EvalWorkerASyncRequest>>,\n) {\n  const { messageType } = e.data;\n\n  if (messageType !== MessageType.REQUEST) return;\n\n  const start = Date.now();\n  const { body, messageId } = e.data;\n  const { method } = body;\n\n  if (!method) return;\n\n  const messageHandler = asyncHandlerMap[method];\n\n  if (typeof messageHandler !== \"function\") return;\n\n  const data = await messageHandler(body);\n  const end = Date.now();\n  const transmissionErrorHandler = transmissionErrorHandlerMap[method];\n\n  WorkerMessenger.respond(\n    messageId,\n    data,\n    start,\n    end,\n    transmissionErrorHandler,\n  );\n}\n\nself.addEventListener(\"message\", syncRequestMessageListener);\nself.addEventListener(\"message\", asyncRequestMessageListener);\n\nself.addEventListener(\"error\", (e) => {\n  e.preventDefault();\n  console.error(e.message);\n});\n\nself.addEventListener(\"unhandledrejection\", (e) => {\n  e.preventDefault();\n  // We might want to send this error to the main thread in the future.\n  // console error will log the error to the logs tab against trigger field.\n  console.error(e.reason.message);\n});\n","import type { JSPropertyPosition, TParsedJSProperty } from \"@shared/ast\";\nimport { isJSFunctionProperty } from \"@shared/ast\";\nimport { set } from \"lodash\";\n\nclass JsPropertiesState {\n  private jsPropertiesState: TJSPropertiesState = {};\n\n  delete(jsObjectName: string) {\n    delete this.jsPropertiesState[`${jsObjectName}`];\n  }\n\n  update(jsObjectName: string, properties: TParsedJSProperty[]) {\n    for (const jsObjectProperty of properties) {\n      const { key, position, rawContent, type } = jsObjectProperty;\n\n      if (isJSFunctionProperty(jsObjectProperty)) {\n        set(\n          this.jsPropertiesState,\n          `[${jsObjectName}.${jsObjectProperty.key}]`,\n          {\n            position: position,\n            value: rawContent,\n            isMarkedAsync: jsObjectProperty.isMarkedAsync,\n          },\n        );\n      } else if (type !== \"literal\") {\n        set(this.jsPropertiesState, `[${jsObjectName}.${key}]`, {\n          position: position,\n          value: rawContent,\n        });\n      }\n    }\n  }\n\n  getMap() {\n    return this.jsPropertiesState;\n  }\n}\n\nexport const jsPropertiesState = new JsPropertiesState();\n\nexport interface TBasePropertyState {\n  value: string;\n  position: JSPropertyPosition;\n}\nexport interface TJSFunctionPropertyState extends TBasePropertyState {\n  isMarkedAsync: boolean;\n}\n\nexport type TJSpropertyState = TBasePropertyState | TJSFunctionPropertyState;\n\nexport type TJSPropertiesState = Record<\n  string,\n  Record<string, TJSpropertyState>\n>;\n","import { serialiseToBigInt } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { WidgetEntity } from \"ee//entities/DataTree/types\";\nimport type { Diff } from \"deep-diff\";\nimport { diff } from \"deep-diff\";\nimport type { DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport equal from \"fast-deep-equal\";\nimport { get, isObject, set } from \"lodash\";\nimport { isMoment } from \"moment\";\nimport { EvalErrorTypes } from \"utils/DynamicBindingUtils\";\n\nexport const fn_keys: string = \"__fn_keys__\";\n\nexport const uniqueOrderUpdatePaths = (updatePaths: string[]) =>\n  Array.from(new Set(updatePaths)).sort((a, b) => b.length - a.length);\n\nexport const getNewDataTreeUpdates = (paths: string[], dataTree: object) =>\n  paths.map((path) => {\n    const segmentedPath = path.split(\".\");\n\n    return {\n      kind: \"N\",\n      path: segmentedPath,\n      rhs: get(dataTree, segmentedPath),\n    };\n  });\n\nexport interface DiffNewTreeState {\n  kind: \"newTree\";\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  rhs: any;\n}\nexport type DiffWithNewTreeState = Diff<DataTree, DataTree> | DiffNewTreeState;\n// Finds the first index which is a duplicate value\n// Returns -1 if there are no duplicates\n// Returns the index of the first duplicate entry it finds\n\n// Note: This \"can\" fail if the object entries don't have their properties in the\n// same order.\nexport const findDuplicateIndex = (arr: Array<unknown>) => {\n  const _uniqSet = new Set();\n  let currSetSize = 0;\n\n  for (let i = 0; i < arr.length; i++) {\n    // JSON.stringify because value can be objects\n    _uniqSet.add(JSON.stringify(arr[i]));\n\n    if (_uniqSet.size > currSetSize) currSetSize = _uniqSet.size;\n    else return i;\n  }\n\n  return -1;\n};\n\n/** Function that count occurrences of a substring in a string;\n * @param {String} string               The string\n * @param {String} subString            The sub string to search for\n * @param {Boolean} [allowOverlapping]  Optional. (Default:false)\n * @param {Number | null} [maxLimit]  Optional. (Default:null)\n */\nexport const countOccurrences = (\n  string: string,\n  subString: string,\n  allowOverlapping = false,\n  maxLimit: number | null = null,\n): number => {\n  string += \"\";\n  subString += \"\";\n\n  if (subString.length <= 0) return string.length + 1;\n\n  let n = 0, // count of occurrences\n    pos = 0; // current position of the pointer\n  const step = allowOverlapping ? 1 : subString.length;\n\n  while (true) {\n    pos = string.indexOf(subString, pos);\n\n    if (pos >= 0) {\n      ++n;\n\n      /**\n       * If you are only interested in knowing\n       * whether occurances count exceeds maxLimit,\n       * then break the loop.\n       */\n      if (maxLimit && n > maxLimit) break;\n\n      pos += step;\n    } else break;\n  }\n\n  return n;\n};\n\nconst LARGE_COLLECTION_SIZE = 100;\n\nexport const stringifyFnsInObject = (\n  userObject: Record<string, unknown>,\n): Record<string, unknown> => {\n  const paths: string[] = parseFunctionsInObject(userObject);\n  const fnStrings: string[] = [];\n\n  for (const path of paths) {\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const fnValue: any = get(userObject, path);\n\n    fnStrings.push(fnValue.toString());\n  }\n\n  const output = JSON.parse(JSON.stringify(userObject));\n\n  for (const [index, parsedFnString] of fnStrings.entries()) {\n    set(output, paths[index], parsedFnString);\n  }\n\n  output[fn_keys] = paths;\n\n  return output;\n};\n\nconst constructPath = (existingPath: string, suffix: string): string => {\n  if (existingPath.length > 0) {\n    return `${existingPath}.${suffix}`;\n  } else {\n    return suffix;\n  }\n};\n\nconst parseFunctionsInObject = (\n  userObject: Record<string, unknown>,\n  paths: string[] = [],\n  path: string = \"\",\n): string[] => {\n  if (Array.isArray(userObject)) {\n    for (let i = 0; i < userObject.length; i++) {\n      const arrayValue = userObject[i];\n\n      if (typeof arrayValue == \"function\") {\n        paths.push(constructPath(path, `[${i}]`));\n      } else if (typeof arrayValue == \"object\") {\n        parseFunctionsInObject(\n          arrayValue,\n          paths,\n          constructPath(path, `[${i}]`),\n        );\n      }\n    }\n  } else {\n    const keys = Object.keys(userObject);\n\n    for (const key of keys) {\n      const value = userObject[key];\n\n      if (typeof value == \"function\") {\n        paths.push(constructPath(path, key));\n      } else if (typeof value == \"object\") {\n        parseFunctionsInObject(\n          value as Record<string, unknown>,\n          paths,\n          constructPath(path, key),\n        );\n      }\n    }\n  }\n\n  return paths;\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst isLargeCollection = (val: any) => {\n  if (!Array.isArray(val)) return false;\n\n  const rowSize = !isObject(val[0]) ? 1 : Object.keys(val[0]).length;\n\n  const size = val.length * rowSize;\n\n  return size > LARGE_COLLECTION_SIZE;\n};\n\nconst getReducedDataTree = (\n  dataTree: DataTree,\n  constrainedDiffPaths: string[],\n): DataTree => {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const withErrors = Object.keys(dataTree).reduce((acc: any, key: string) => {\n    const widgetValue = dataTree[key] as WidgetEntity;\n\n    acc[key] = {\n      __evaluation__: {\n        errors: widgetValue.__evaluation__?.errors,\n      },\n    };\n\n    return acc;\n  }, {});\n\n  return constrainedDiffPaths.reduce((acc: DataTree, key: string) => {\n    set(acc, key, get(dataTree, key));\n\n    return acc;\n  }, withErrors);\n};\nconst generateDiffUpdates = (\n  oldDataTree: DataTree,\n  dataTree: DataTree,\n  constrainedDiffPaths: string[],\n): Diff<DataTree, DataTree>[] => {\n  const attachDirectly: Diff<DataTree, DataTree>[] = [];\n  const attachLater: Diff<DataTree, DataTree>[] = [];\n\n  // we are reducing the data tree to only the paths that are being diffed\n  const oldData = getReducedDataTree(oldDataTree, constrainedDiffPaths);\n  const newData = getReducedDataTree(dataTree, constrainedDiffPaths);\n  const updates =\n    diff(oldData, newData, (path, key) => {\n      if (!path.length || key === \"__evaluation__\") return false;\n\n      const segmentedPath = [...path, key];\n\n      const rhs = get(dataTree, segmentedPath) as DataTree;\n\n      const lhs = get(oldDataTree, segmentedPath) as DataTree;\n\n      //when a moment value changes we do not want the inner moment object updates, we just want the ISO result of it\n      // which we get during the serialisation process we perform at latter steps\n      if (isMoment(rhs)) {\n        attachDirectly.push({\n          kind: \"E\",\n          lhs,\n          // TODO: Fix this the next time the file is edited\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          rhs: rhs as any,\n          path: segmentedPath,\n        });\n\n        // ignore trying to diff moment objects\n        return true;\n      }\n\n      if (rhs === undefined) {\n        //if an undefined value is being set it should be a delete\n        if (lhs !== undefined) {\n          attachDirectly.push({ kind: \"D\", lhs, path: segmentedPath });\n        }\n\n        return true;\n      }\n\n      const isLhsLarge = isLargeCollection(lhs);\n      const isRhsLarge = isLargeCollection(rhs);\n\n      if (!isLhsLarge && !isRhsLarge) {\n        //perform diff on this node\n        return false;\n      }\n\n      //if either of values are large just directly attach it don't have to generate very granular updates\n\n      if ((!isLhsLarge && isRhsLarge) || (isLhsLarge && !isRhsLarge)) {\n        attachDirectly.push({ kind: \"N\", path: segmentedPath, rhs });\n\n        return true;\n      }\n\n      //if the values are different attach the update directly\n      !equal(lhs, rhs) &&\n        attachDirectly.push({ kind: \"N\", path: segmentedPath, rhs });\n\n      //ignore diff on this node\n      return true;\n    }) || [];\n\n  const largeDataSetUpdates = [...attachDirectly, ...attachLater];\n\n  return [...updates, ...largeDataSetUpdates];\n};\n\nconst correctUndefinedUpdatesToDeletesOrNew = (\n  updates: Diff<DataTree, DataTree>[],\n) =>\n  updates.reduce(\n    (acc, update) => {\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const { kind, lhs, path, rhs } = update as any;\n\n      if (kind === \"E\") {\n        if (lhs === undefined && rhs !== undefined) {\n          acc.push({ kind: \"N\", path, rhs });\n        }\n\n        if (lhs !== undefined && rhs === undefined) {\n          acc.push({ path, lhs, kind: \"D\" });\n        }\n\n        if (lhs !== undefined && rhs !== undefined) {\n          acc.push(update);\n        }\n\n        return acc;\n      }\n\n      acc.push(update);\n\n      return acc;\n    },\n    [] as Diff<DataTree, DataTree>[],\n  );\n\n// whenever an element in a collection is set to undefined, we need to send the entire collection as an update\nconst generateRootWidgetUpdates = (\n  updates: Diff<DataTree, DataTree>[],\n  newDataTree: DataTree,\n  oldDataTree: DataTree,\n): Diff<DataTree, DataTree>[] =>\n  updates\n    .filter(\n      (v) =>\n        v.kind === \"D\" &&\n        v.path &&\n        typeof v.path[v.path.length - 1] === \"number\",\n    )\n    .map(\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      ({ path }: any) => {\n        const pathCopy = [...path];\n\n        pathCopy.pop();\n\n        return {\n          kind: \"E\",\n          path: pathCopy,\n          lhs: get(oldDataTree, pathCopy) as DataTree,\n          rhs: get(newDataTree, pathCopy) as DataTree,\n        }; //push the parent path\n      },\n      [] as Diff<DataTree, DataTree>[],\n    );\n\n// when a root collection is updated, we need to scrub out updates that are inside the root collection\nconst getScrubbedOutUpdatesWhenRootCollectionIsUpdated = (\n  updates: Diff<DataTree, DataTree>[],\n  rootCollectionUpdates: Diff<DataTree, DataTree>[],\n) => {\n  const rootCollectionPaths = rootCollectionUpdates\n    .filter((update) => update?.path?.length)\n    .map((update) => (update.path as string[]).join(\".\"));\n\n  return (\n    updates // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      .map((update: any) => ({ update, condensedPath: update.path.join(\".\") }))\n      .filter(\n        ({ condensedPath }) =>\n          !rootCollectionPaths.some((p) => condensedPath.startsWith(p)),\n      )\n      // remove the condensedPath from the update\n      .map(({ update }) => update)\n  );\n};\n\nexport const generateOptimisedUpdates = (\n  oldDataTree: DataTree,\n  dataTree: DataTree,\n  // these are the paths that the diff is limited to, this is a performance optimisation and through this we don't have to diff the entire data tree\n  constrainedDiffPaths: string[],\n): Diff<DataTree, DataTree>[] => {\n  const updates = generateDiffUpdates(\n    oldDataTree,\n    dataTree,\n    constrainedDiffPaths,\n  );\n  const correctedUpdates = correctUndefinedUpdatesToDeletesOrNew(updates);\n\n  const rootCollectionUpdates = generateRootWidgetUpdates(\n    correctedUpdates,\n    dataTree,\n    oldDataTree,\n  );\n  const scrubedOutUpdates = getScrubbedOutUpdatesWhenRootCollectionIsUpdated(\n    correctedUpdates,\n    rootCollectionUpdates,\n  );\n\n  return [...scrubedOutUpdates, ...rootCollectionUpdates];\n};\n\nexport const generateSerialisedUpdates = (\n  prevState: DataTree,\n  currentState: DataTree,\n  constrainedDiffPaths: string[],\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  mergeAdditionalUpdates?: any,\n): {\n  serialisedUpdates: string;\n  error?: { type: string; message: string };\n} => {\n  const updates = generateOptimisedUpdates(\n    prevState,\n    currentState,\n    constrainedDiffPaths,\n  );\n\n  //remove lhs from diff to reduce the size of diff upload,\n  //it is not necessary to send lhs and we can make the payload to transfer to the main thread smaller for quicker transfer\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any\n  let removedLhs = updates.map(({ lhs, ...rest }: any) => rest);\n\n  removedLhs = [...removedLhs, ...(mergeAdditionalUpdates || [])];\n\n  try {\n    // serialise bigInt values and convert the updates to a string over here to minismise the cost of transfer\n    // to the main thread. In the main thread parse this object there.\n    return { serialisedUpdates: serialiseToBigInt(removedLhs) };\n  } catch (error) {\n    return {\n      serialisedUpdates: \"[]\",\n      error: {\n        type: EvalErrorTypes.SERIALIZATION_ERROR,\n        message: (error as Error).message,\n      },\n    };\n  }\n};\n\nexport const generateOptimisedUpdatesAndSetPrevState = (\n  dataTree: DataTree,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  dataTreeEvaluator: any,\n  constrainedDiffPaths: string[],\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  mergeAdditionalUpdates?: any,\n) => {\n  const { error, serialisedUpdates } = generateSerialisedUpdates(\n    dataTreeEvaluator?.getPrevState() || {},\n    dataTree,\n    constrainedDiffPaths,\n    mergeAdditionalUpdates,\n  );\n\n  if (error && dataTreeEvaluator?.errors) {\n    dataTreeEvaluator.errors.push(error);\n  }\n\n  dataTreeEvaluator?.setPrevState(dataTree);\n\n  return serialisedUpdates;\n};\n","import type {\n  PropertyOverrideDependency,\n  OverridingPropertyPaths,\n  WidgetEntity,\n  ActionEntity,\n  JSActionEntity,\n} from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { OverridingPropertyType } from \"ee/entities/DataTree/types\";\nimport {\n  isAction,\n  isJSAction,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { Module } from \"ee/constants/ModuleConstants\";\ninterface SetOverridingPropertyParams {\n  key: string;\n  value: string;\n  propertyOverrideDependency: PropertyOverrideDependency;\n  overridingPropertyPaths: OverridingPropertyPaths;\n  type: OverridingPropertyType;\n}\n\nexport const setOverridingProperty = ({\n  key: propertyName,\n  overridingPropertyPaths,\n  propertyOverrideDependency,\n  type,\n  value: overridingPropertyKey,\n}: SetOverridingPropertyParams) => {\n  if (!(propertyName in propertyOverrideDependency)) {\n    propertyOverrideDependency[propertyName] = {\n      [OverridingPropertyType.DEFAULT]: undefined,\n      [OverridingPropertyType.META]: undefined,\n    };\n  }\n\n  switch (type) {\n    case OverridingPropertyType.DEFAULT:\n      propertyOverrideDependency[propertyName][OverridingPropertyType.DEFAULT] =\n        overridingPropertyKey;\n      break;\n\n    case OverridingPropertyType.META:\n      propertyOverrideDependency[propertyName][OverridingPropertyType.META] =\n        overridingPropertyKey;\n\n      break;\n    default:\n  }\n\n  if (Array.isArray(overridingPropertyPaths[overridingPropertyKey])) {\n    const updatedOverridingProperty = new Set(\n      overridingPropertyPaths[overridingPropertyKey],\n    );\n\n    overridingPropertyPaths[overridingPropertyKey] = [\n      ...updatedOverridingProperty.add(propertyName),\n    ];\n  } else {\n    overridingPropertyPaths[overridingPropertyKey] = [propertyName];\n  }\n\n  // if property dependent on metaProperty also has defaultProperty then defaultProperty will also override metaProperty on eval.\n  const defaultPropertyName = propertyOverrideDependency[propertyName].DEFAULT;\n\n  if (type === OverridingPropertyType.META && defaultPropertyName) {\n    overridingPropertyPaths[defaultPropertyName].push(overridingPropertyKey);\n  }\n};\n\nexport const generateDataTreeModuleInputs = (\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  moduleInputs: Module[\"inputsForm\"],\n) => {\n  return {\n    unEvalEntity: null,\n    configEntity: null,\n  };\n};\n\nexport function isWidgetActionOrJsObject(\n  entity: DataTreeEntity,\n): entity is ActionEntity | WidgetEntity | JSActionEntity {\n  return isWidget(entity) || isAction(entity) || isJSAction(entity);\n}\n","import { uuid4 } from \"@sentry/utils\";\nimport type {\n  LogObject,\n  Methods,\n  SourceEntity,\n} from \"entities/AppsmithConsole\";\nimport { Severity } from \"entities/AppsmithConsole\";\nimport { ENTITY_TYPE } from \"ee/entities/AppsmithConsole/utils\";\nimport { klona } from \"klona/lite\";\nimport type { TriggerMeta } from \"ee/sagas/ActionExecution/ActionExecutionSagas\";\nimport TriggerEmitter from \"../utils/TriggerEmitter\";\nimport type { EventEmitter } from \"events\";\nimport ExecutionMetaData from \"../utils/ExecutionMetaData\";\n\nclass UserLog {\n  private isEnabled = true;\n\n  enable() {\n    this.isEnabled = true;\n  }\n\n  disable() {\n    this.isEnabled = false;\n  }\n\n  private emitter?: EventEmitter;\n\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private saveLog(method: Methods, data: any[]) {\n    const parsed = this.parseLogs(method, data);\n\n    this.emitter?.emit(\"process_logs\", parsed);\n  }\n\n  public overrideConsoleAPI() {\n    this.emitter = TriggerEmitter;\n    const { debug, error, info, log, table, warn } = console;\n\n    console = {\n      ...console,\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      table: (...args: any) => {\n        if (!this.isEnabled) return;\n\n        table.call(this, args);\n        this.saveLog(\"table\", args);\n      },\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      error: (...args: any) => {\n        if (!this.isEnabled) return;\n\n        error.apply(this, args);\n        this.saveLog(\"error\", args);\n      },\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      log: (...args: any) => {\n        if (!this.isEnabled) return;\n\n        log.apply(this, args);\n        this.saveLog(\"log\", args);\n      },\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      debug: (...args: any) => {\n        if (!this.isEnabled) return;\n\n        debug.apply(this, args);\n        this.saveLog(\"debug\", args);\n      },\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      warn: (...args: any) => {\n        if (!this.isEnabled) return;\n\n        warn.apply(this, args);\n        this.saveLog(\"warn\", args);\n      },\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      info: (...args: any) => {\n        if (!this.isEnabled) return;\n\n        info.apply(this, args);\n        this.saveLog(\"info\", args);\n      },\n    };\n  }\n\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private replaceFunctionWithNamesFromObjects(data: any) {\n    if (typeof data === \"function\") return `func() ${data.name}`;\n\n    if (!data || typeof data !== \"object\") return data;\n\n    if (data instanceof Promise) return \"Promise\";\n\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const acc: any =\n      Object.prototype.toString.call(data) === \"[object Array]\" ? [] : {};\n\n    return Object.keys(data).reduce((acc, key) => {\n      acc[key] = this.replaceFunctionWithNamesFromObjects(data[key]);\n\n      return acc;\n    }, acc);\n  }\n\n  // iterates over the data and if data is object/array, then it will remove any functions from it\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private sanitizeData(data: any): any {\n    try {\n      const returnData = this.replaceFunctionWithNamesFromObjects(data);\n\n      return returnData;\n    } catch (e) {\n      return [`There was some error: ${e} ${JSON.stringify(data)}`];\n    }\n  }\n\n  private getSource = (triggerMeta?: TriggerMeta): SourceEntity => {\n    const type = triggerMeta?.source?.entityType || ENTITY_TYPE.JSACTION;\n    const name =\n      triggerMeta?.source?.name || triggerMeta?.triggerPropertyName || \"\";\n    const propertyPath = triggerMeta?.triggerPropertyName || \"\";\n    const id = triggerMeta?.source?.id || \"\";\n\n    //@ts-expect-error : we are not using the source entity in the console\n    return { type, name, id, propertyPath };\n  };\n\n  // parses the incoming log and converts it to the log object\n  private parseLogs(method: Methods, data: unknown[]): LogObject {\n    // Create an ID\n    const id = uuid4();\n    const timestamp = Date.now().toString();\n    // Parse the methods\n    let output = data;\n    // For logs UI we only keep 3 levels of severity, info, warn, error\n    let severity = Severity.INFO;\n\n    if (method === \"error\") {\n      severity = Severity.ERROR;\n      output = data.map((error) => {\n        return (error as Error).stack || error;\n      });\n    } else if (method === \"warn\") {\n      severity = Severity.WARNING;\n    }\n\n    const { triggerMeta } = ExecutionMetaData.getExecutionMetaData();\n\n    return {\n      method,\n      id,\n      data: this.sanitizeData(klona(output)),\n      timestamp,\n      severity,\n      source: this.getSource(triggerMeta),\n    };\n  }\n}\n\nconst userLogs = new UserLog();\n\nexport default userLogs;\n","export const ECMA_VERSION = 11;\n\n/* Indicates the mode the code should be parsed in. \nThis influences global strict mode and parsing of import and export declarations.\n*/\nexport enum SourceType {\n  script = \"script\",\n  module = \"module\",\n}\n\n// Each node has an attached type property which further defines\n// what all properties can the node have.\n// We will just define the ones we are working with\nexport enum NodeTypes {\n  Identifier = \"Identifier\",\n  AssignmentPattern = \"AssignmentPattern\",\n  Literal = \"Literal\",\n  Property = \"Property\",\n  RestElement = \"RestElement\",\n  ObjectPattern = \"ObjectPattern\",\n  ArrayPattern = \"ArrayPattern\",\n  // Declaration - https://github.com/estree/estree/blob/master/es5.md#declarations\n  FunctionDeclaration = \"FunctionDeclaration\",\n  ExportDefaultDeclaration = \"ExportDefaultDeclaration\",\n  VariableDeclarator = \"VariableDeclarator\",\n  // Expression - https://github.com/estree/estree/blob/master/es5.md#expressions\n  MemberExpression = \"MemberExpression\",\n  FunctionExpression = \"FunctionExpression\",\n  ArrowFunctionExpression = \"ArrowFunctionExpression\",\n  AssignmentExpression = \"AssignmentExpression\",\n  ObjectExpression = \"ObjectExpression\",\n  ArrayExpression = \"ArrayExpression\",\n  ThisExpression = \"ThisExpression\",\n  CallExpression = \"CallExpression\",\n  BinaryExpression = \"BinaryExpression\",\n  ExpressionStatement = \"ExpressionStatement\",\n  BlockStatement = \"BlockStatement\",\n  ConditionalExpression = \"ConditionalExpression\",\n  AwaitExpression = \"AwaitExpression\",\n}\n","import { dataTreeEvaluator } from \"./evalTree\";\nimport type { EvalWorkerSyncRequest } from \"../types\";\nimport set from \"lodash/set\";\nimport { evalTreeWithChanges } from \"../evalTreeWithChanges\";\nimport DataStore from \"../dataStore\";\nimport { EVAL_WORKER_SYNC_ACTION } from \"ee/workers/Evaluation/evalWorkerActions\";\nimport type { DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport type { UpdateActionProps } from \"./types\";\n\nexport default function (request: EvalWorkerSyncRequest) {\n  const actionsDataToUpdate: UpdateActionProps[] = request.data;\n\n  handleActionsDataUpdate(actionsDataToUpdate);\n\n  return true;\n}\n\nexport function handleActionsDataUpdate(actionsToUpdate: UpdateActionProps[]) {\n  if (!dataTreeEvaluator) {\n    return {};\n  }\n\n  const evalTree = dataTreeEvaluator.getEvalTree();\n\n  updateActionsToEvalTree(evalTree, actionsToUpdate);\n\n  const updatedProperties: string[][] = [];\n\n  actionsToUpdate.forEach(({ dataPath, entityName }) => {\n    updatedProperties.push([entityName, dataPath]);\n  });\n  evalTreeWithChanges({\n    data: {\n      updatedValuePaths: updatedProperties,\n      metaUpdates: [],\n    },\n    method: EVAL_WORKER_SYNC_ACTION.EVAL_TREE_WITH_CHANGES,\n    webworkerTelemetry: {},\n  });\n}\n\nexport function updateActionsToEvalTree(\n  evalTree: DataTree,\n  actionsToUpdate?: UpdateActionProps[],\n) {\n  if (!actionsToUpdate) return;\n\n  for (const actionToUpdate of actionsToUpdate) {\n    const { dataPath, dataPathRef, entityName } = actionToUpdate;\n    let { data } = actionToUpdate;\n\n    if (dataPathRef) {\n      data = DataStore.getActionData(dataPathRef);\n      DataStore.deleteActionData(dataPathRef);\n    }\n\n    // update the evaltree\n    set(evalTree, `${entityName}.[${dataPath}]`, data);\n    // Update context\n    set(self, `${entityName}.[${dataPath}]`, data);\n    // Update the datastore\n    const path = `${entityName}.${dataPath}`;\n\n    DataStore.setActionData(path, data);\n  }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n// the startup function\n__webpack_require__.x = () => {\n\t// Load entry module and return exports\n\t// This entry module depends on other loaded chunks and execution need to be delayed\n\tvar __webpack_exports__ = __webpack_require__.O(undefined, [9222,5477,3222,9922,3350,2327], () => (__webpack_require__(85688)))\n\t__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n\treturn __webpack_exports__;\n};\n\n","__webpack_require__.amdO = {};","var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar chunkIds = deferred[i][0];\n\t\tvar fn = deferred[i][1];\n\t\tvar priority = deferred[i][2];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"static/js/\" + ({\"248\":\"auto-track\",\"521\":\"remoteMiddleware\",\"3104\":\"schemaFilter\",\"5021\":\"blueprint-icons\",\"5050\":\"ajs-destination\",\"6999\":\"remix-icons\",\"7538\":\"queryString\",\"9010\":\"tsub-middleware\",\"9222\":\"svg-icons\",\"9694\":\"legacyVideos\"}[chunkId] || chunkId) + \".\" + {\"248\":\"f008a257\",\"521\":\"0e5b22a7\",\"2327\":\"a2e54e7a\",\"3104\":\"1b02f095\",\"3222\":\"28fba642\",\"3350\":\"c966ed96\",\"3646\":\"038bfa00\",\"4831\":\"89c721f8\",\"4996\":\"e58b4ba4\",\"5021\":\"9cef11d0\",\"5050\":\"c80d51a1\",\"5477\":\"d91710cb\",\"6999\":\"cf894592\",\"7538\":\"1b09bb08\",\"8081\":\"8867453f\",\"8627\":\"3466c660\",\"9010\":\"03b316e9\",\"9222\":\"bf84475d\",\"9694\":\"dd96c20e\",\"9922\":\"b2cf3dde\"}[chunkId] + \".chunk.js\";\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.miniCssF = (chunkId) => {\n\t// return url for filenames based on template\n\treturn undefined;\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","__webpack_require__.j = 8663;","__webpack_require__.p = \"/\";","(() => {\n  if (typeof __webpack_require__ !== 'undefined') {\n    var oldGetScript = __webpack_require__.u;\n    var oldLoadScript = __webpack_require__.e;\n    var queryMap = {};\n    var countMap = {};\n    var getRetryDelay = function () {\n      return 3000;\n    };\n    __webpack_require__.u = function (chunkId) {\n      var result = oldGetScript(chunkId);\n      return (\n        result +\n        (queryMap.hasOwnProperty(chunkId) ? '?' + queryMap[chunkId] : '')\n      );\n    };\n    __webpack_require__.e = function (chunkId) {\n      var result = oldLoadScript(chunkId);\n      return result.catch(function (error) {\n        var retries = countMap.hasOwnProperty(chunkId) ? countMap[chunkId] : 2;\n        if (retries < 1) {\n          var realSrc = oldGetScript(chunkId);\n          error.message =\n            'Loading chunk ' +\n            chunkId +\n            ' failed after 2 retries.\\n(' +\n            realSrc +\n            ')';\n          error.request = realSrc;\n          window.location.href = '/404.html';\n          throw error;\n        }\n        return new Promise(function (resolve) {\n          var retryAttempt = 2 - retries + 1;\n          setTimeout(function () {\n            var retryAttemptString = '&retry-attempt=' + retryAttempt;\n            var cacheBust = 'cache-bust=true' + retryAttemptString;\n            queryMap[chunkId] = cacheBust;\n            countMap[chunkId] = retries - 1;\n            resolve(__webpack_require__.e(chunkId));\n          }, getRetryDelay(retryAttempt));\n        });\n      });\n    };\n  }\n})();\n","// no baseURI\n\n// object to store loaded chunks\n// \"1\" means \"already loaded\"\nvar installedChunks = {\n\t976: 1,\n\t8663: 1\n};\n\n// importScripts chunk loading\nvar installChunk = (data) => {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\tfor(var moduleId in moreModules) {\n\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t}\n\t}\n\tif(runtime) runtime(__webpack_require__);\n\twhile(chunkIds.length)\n\t\tinstalledChunks[chunkIds.pop()] = 1;\n\tparentChunkLoadingFunction(data);\n};\n__webpack_require__.f.i = (chunkId, promises) => {\n\t// \"1\" is the signal for \"already loaded\"\n\tif(!installedChunks[chunkId]) {\n\t\tif(true) { // all chunks have JS\n\t\t\timportScripts(__webpack_require__.p + __webpack_require__.u(chunkId));\n\t\t}\n\t}\n};\n\nvar chunkLoadingGlobal = self[\"webpackChunkappsmith\"] = self[\"webpackChunkappsmith\"] || [];\nvar parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);\nchunkLoadingGlobal.push = installChunk;\n\n// no HMR\n\n// no HMR manifest","__webpack_require__.nc = undefined;","var next = __webpack_require__.x;\n__webpack_require__.x = () => {\n\treturn Promise.all([9222,5477,3222,9922,3350,2327].map(__webpack_require__.e, __webpack_require__)).then(next);\n};","// run startup\nvar __webpack_exports__ = __webpack_require__.x();\n"],"names":["beginsWithLineBreakRegex","sanitizeScript","js","evaluationVersion","trimmedJS","replace","unescapeJS","extractContentByPosition","content","position","eachLine","split","returnedString","i","from","line","to","slice","ch","getStringValue","inputValue","JSON","stringify","getEntityForEvalContextMap","ENTITY_TYPE","JSACTION","entityName","entity","getJSActionForEvalContext","getEntityForEvalContext","getterMethod","getDataTreeContext","args","configTree","dataTree","isTriggerBased","removeEntityFunctions","EVAL_CONTEXT","dataTreeEntries","Object","entries","entityFunctionCollection","setters","clear","entityFn","getEntityFunctions","qualifier","func","fn","fullPath","path","name","set","entityConfig","entityMethodMap","getEntitySettersFromConfig","_isEmpty","assign","removeEntityFunctionsFromEvalContext","addEntityFunctionsToEvalContext","evalContext","funcObj","addPlatformFunctionsToEvalContext","context","fnDef","getPlatformFunctions","addFn","bind","getAllSetterFunctions","entitiesSetterFunctions","methodName","keys","getEntitySetterFunctions","entitySetterFunctions","getAllAsyncFunctions","allAsyncFunctions","setterMethods","platformFn","klona","forEach","newWebWorkerSpanData","spanName","attributes","arguments","length","undefined","startTime","Date","now","endTime","addEndTimeForWebWorkerSpanData","span","profileAsyncFn","async","allSpans","res","profileFn","defaultLibraries","accessor","version","lodashPackageJson","docsURL","momentPackageJson","JSLibraries","JSLibraryAccessor","JSLibraryAccessorModifier","jsLibraryAccessorSet","Set","flatMap","lib","regenerateSet","getSet","libraryReservedIdentifiers","reduce","acc","a","isDynamicValue","value","DATA_BIND_REGEX","test","getDynamicStringSegments","dynamicString","stringSegments","indexOfDoubleParanStart","indexOf","firstString","substring","push","rest","sum","char","prevChar","concat","getDynamicBindings","_isString","jsSnippets","sanitisedString","trim","isJSAction","map","segment","EvalErrorTypes","getEntityDynamicBindingPathList","dynamicBindingPathList","Array","isArray","isPathADynamicBinding","_find","key","isPathDynamicTrigger","widget","dynamicTriggerPathList","unsafeFunctionForEval","isChildPropertyPath","parentPropertyPath","childPropertyPath","startsWith","EVALUATION_PATH","EVAL_ERROR_PATH","EVAL_VALUE_PATH","getNestedEvalPath","fullPropertyPath","pathType","isPopulated","propertyPath","getEntityNameAndPropertyPath","nestedPath","getEvalErrorPath","options","getEvalValuePath","PropertyEvaluationErrorType","PropertyEvaluationErrorCategory","VALIDATION","PARSE","LINT","getEntityId","isAction","actionId","isWidget","widgetId","getEntityName","widgetName","WorkerEnv","setFeatureFlags","featureFlags","flags","setCloudHosting","cloudHosting","getFeatureFlags","getCloudHosting","ctx","fnName","fnGuards","isAsyncGuard","defineProperty","getFnWithGuards","fnWithGuards","enumerable","writable","configurable","self","$isDataField","ActionCalledInSyncFieldError","guard","updateJSCollectionInUnEvalTree","parsedBody","jsCollection","unEvalTree","modifiedUnEvalTree","functionsList","jsEntityConfig","varList","variables","meta","action","oldConfig","actions","hasOwnProperty","body","data","_get","_set","String","reactivePaths","EvaluationSubstitutionType","SMART_SUBSTITUTE","TEMPLATE","dependencyMap","confirmBeforeExecute","toString","oldActionName","find","filter","item","_unset","newVar","existedVarVal","JSObjectCollection","removeVariable","newVarList","varListItem","removeFunctionsAndVariableJSCollection","modifiedDataTree","varName","actionName","isJSObjectFunction","jsObjectName","isJSObjectVariable","includes","isPromise","Boolean","then","getPrunedReferences","references","allKeys","prunedReferences","reference","add","subpaths","_toPath","current","convertPathToString","pop","extractInfoFromBindings","bindings","bindingsInfo","binding","extractInfoFromBinding","script","extractIdentifierInfoFromCode","invalidEntityIdentifiers","_union","error","newEvalError","type","EXTRACT_DEPENDENCY_ERROR","message","errors","JAVASCRIPT_KEYWORDS","DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS","convertArrayToObject","arr","EvaluationScriptType","ScriptTemplate","EvaluationScripts","EXPRESSION","ANONYMOUS_FUNCTION","ASYNC_ANONYMOUS_FUNCTION","TRIGGERS","OBJECT_PROPERTY","topLevelWorkerAPIs","ignoreGlobalObjectKeys","resetWorkerGlobalScope","DOM_APIS","has","e","overrideEvalContext","overrideContext","entitiesClonedSoFar","_ref","createEvaluationContext","evalArguments","ARGUMENTS","THIS_CONTEXT","thisContext","globalContext","dataTreeContext","getUserScriptToEvaluate","userScript","unescapedJS","scriptType","evalArgumentsExist","getScriptType","getScriptToEval","buffer","setEvalContext","_ref2","isDataField","evaluateSync","isJSCollection","evalContextCache","result","triggers","indirectEval","Promise","FoundPromiseInSyncEvalError","errorCategory","errorMessage","rootcause","errorModifier","run","source","ActionInDataFieldErrorModifier","TypeErrorModifier","severity","Severity","ERROR","raw","errorType","originalBinding","kind","category","evaluateAsync","PrimitiveErrorModifier","shouldAddSetter","setter","isDisabledExpression","disabled","Function","isDisabledFn","objectKeys","object","Types","getType","STRING","_isNumber","NUMBER","_isBoolean","BOOLEAN","ARRAY","_isFunction","FUNCTION","_isObject","OBJECT","_isUndefined","UNDEFINED","_isNull","NULL","UNKNOWN","isIdentifierNode","node","NodeTypes","Identifier","isMemberExpressionNode","MemberExpression","isVariableDeclarator","VariableDeclarator","isFunctionDeclaration","FunctionDeclaration","isFunctionExpression","FunctionExpression","isArrowFunctionExpression","ArrowFunctionExpression","isObjectExpression","ObjectExpression","isArrayPatternNode","ArrayPattern","isObjectPatternNode","ObjectPattern","isLiteralNode","Literal","isExportDefaultDeclarationNode","ExportDefaultDeclaration","isPropertyAFunctionNode","isArrayAccessorNode","computed","property","isFinite","wrapCode","code","getFunctionalParamNamesFromNode","getFunctionalParamsFromNode","functionalParam","paramName","getAST","parse","ecmaVersion","ECMA_VERSION","invalidIdentifiers","ast","end","start","sanitizedScript","wrappedCode","functionalParams","variableDeclarations","ancestorWalk","topLevelIdentifier","toPath","isError","SyntaxError","needValue","params","paramNode","defaultValue","AssignmentPattern","isAssignmentPatternNode","left","defaultValueInString","right","RestElement","isRestElementNode","argument","constructFinalMemberExpIdentifier","child","propertyAccessor","getPropertyAccessor","nestedChild","propertyNode","isString","isTypeOfFunction","identifierList","ancestor","ancestors","candidateTopLevelNode","depth","parent","optional","parentNode","memberExpIdentifier","id","getMemberExpressionObjectFromProperty","propertyName","memberExpressionObjects","locations","simple","propName","isNil","memberExpressionObjectString","generate","UPDATES","TOASTS","FOCUSES","WIDGETS","setPropertyUpdate","replay","existingPathValue","addToArray","obj","getPathsFromDiff","diffs","paths","diff","join","pathArrayToString","stringPath","isNaN","parseInt","getFixedTimeDifference","toFixed","triggerPaths","replaceThisDotParams","EXECUTION_PARAM_REFERENCE_REGEX","THIS_DOT_PARAMS_KEY","getAllAsyncJSFunctions","unevalTree","jsPropertiesState","allAsyncNodes","allAsyncJSFunctions","jsEntityState","propertyState","isMarkedAsync","getAllReachableNodes","getValidEntityType","entityType","isValidEntity","getOnlyAffectedJSObjects","jsDataTree","affectedJSObjects","ids","isAllAffected","idsSet","getIsNewWidgetAdded","translatedDiffs","some","diffEvent","event","DataTreeDiffEvent","NEW","payload","validateAndParseWidgetProperty","evalPropertyValue","evalProps","unEvalPropertyValue","validation","validationPaths","isValid","messages","parsed","validateWidgetProperty","resetValidationErrorsForEntityProperty","_messages$map","evalErrors","addErrorToEntityProperty","config","props","validate","validateActionProperty","EVAL_WORKER_SYNC_ACTION","EVAL_WORKER_ASYNC_ACTION","EVAL_WORKER_ACTIONS","MAIN_THREAD_ACTION","getUpdatedLocalUnEvalTreeAfterJSUpdates","jsUpdates","localUnEvalTree","jsEntity","validJSBodyRegex","RegExp","saveResolvedFunctionsAndJSUpdates","dataTreeEvalRef","unEvalDataTree","delete","correctFormat","isEmptyBody","deleteResolvedFunction","deleteUnEvalState","clearCachedVariablesForEvaluationContext","parseStartTime","performance","parsedObject","success","parseJSObject","parseEndTime","JSObjectASTParseTime","logs","JSObjectName","actionsMap","variablesMap","update","parsedElement","isJSFunctionProperty","ExecutionMetaData","setExecutionMetaData","enableJSVarUpdateTracking","enableJSFnPostProcessors","functionString","updateResolvedFunctions","updateUnEvalState","parsedKey","values","PARSE_JS_ERROR","parseJSActions","oldUnEvalTree","differences","resolvedFunctions","getResolvedFunctions","unEvalState","getUnEvalState","DELETE","EDIT","getJSEntities","jsCollections","updateEvalTreeWithJSCollectionState","evalTree","getVariableState","jsCollectionEntries","variableState","updateEvalTreeValueFromContext","currentEvalContext","dataTreeEvaluator","getEvalTree","fullPathArray","variableName","setVariableValue","_internalSetInterval","setInterval","_internalClearInterval","clearInterval","intervalIdMap","Map","clearAllIntervals","intervalId","runningIntervalId","get","callback","delay","_len","_key","metaData","getExecutionMetaData","_internalIntervalId","customIntervalId","ActionParentEntityType","CE_ActionParentEntityType","positionProps","ReplayCanvas","ReplayEntity","constructor","super","WIDGET","processDiff","isUndo","this","processDiffForWidgets","processDiffForTheme","toast","createToast","rhs","widgets","lhs","widgetProperty","diffWidget","dslWidget","isCreated","filterBindingSegmentsAndRemoveQuotes","subSegments","subSegmentValues","bindingStrippedQuotes","QUOTED_BINDING_REGEX","original","firstGroup","subBindings","subValues","substituteDynamicBindingWithValues","evaluationSubstitutionType","templateSubstituteDynamicValues","finalValue","b","smartSubstituteDynamicValues","finalBinding","PARAMETER","parameterSubstituteDynamicValues","Error","parameters","getDependencies","ACTION","actionEntity","actionConfig","dependencies","actionDependencyMap","pathDeps","propertyPathDependencies","dependentPath","dynamicPath","dynamicPathDependencies","getDependencyFromEntityPath","existingDeps","newDependencies","getActionDependencies","jsActionConfig","jsActionReactivePaths","jsActionDependencyMap","reactivePath","reactivePathDependencies","newDeps","getJSDependencies","widgetEntity","widgetConfig","addWidgetPropertyDependencies","targetPaths","p","bindingPath","getWidgetDependencies","getPathDependencies","_actionInternalDepend","actionPathDependencies","actionInternalDependencyMap","actionPathInternalDependencies","dep","bindingPaths","getActionPropertyPathDependencies","_jsInternalDependency","_jsInternalDependency2","jsInternalDependencyMap","jsPathInternalDependencies","getJSPropertyPathDependencies","widgetPathInternalDependencies","isATriggerPath","getWidgetPropertyPathDependencies","getEntityDependencies","isWidgetActionOrJsObject","getEntityPathDependencies","unevalPropValue","jsSnippet","DependencyMapUtils","sortDependencies","dependencyTree","rawDependencies","deps","size","sortedDependencies","toposort","reverse","edge","cyclicNodes","match","cyclicNode","makeParentsDependOnChildren","makeParentsDependOnChild","linkAffectedChildNodesToParent","affectedSet","matches","curKey","IMMEDIATE_PARENT_REGEX","immediateParent","existingImmediateParentDeps","getDirectDependencies","addDependency","EComputationCacheName","AppComputationCache","store","cacheLogsStore","appModeConfig","DEPENDENCY_MAP","APP_MODE","PUBLISHED","ALL_KEYS","debouncedDeleteInvalidCacheEntries","debounce","deleteInvalidCacheEntries","localforage","storeName","getInstance","instance","isComputationCached","cacheName","cacheProps","appMode","timestamp","cacheComputationResult","computationResult","cacheKey","generateCacheKey","setItem","trackCacheUsage","loglevel","getCachedComputationResult","_ref3","cached","getItem","isNull","setTimeout","_ref4","appId","instanceId","pageId","getTime","CACHE_KEY_DELIMITER","fetchOrCompute","_ref5","computeFn","cachedResult","currentLog","lastAccessedAt","createdAt","invalidCacheKeys","keyParts","cacheKeyTimestamp","all","removeItem","resetInstance","addingAffectedNodesToList","affectedNodes","addedNodes","v","updateDependencyMap","diffCalcStart","dependenciesOfRemovedPaths","removedPaths","didUpdateDependencyMap","oldConfigTree","dataTreeEvalErrors","addNodesToDepedencyMapFn","addNodesToDependencyMap","strict","didUpdateDep","addNodes","setDependenciesToDepedencyMapFn","setDependenciesToDependencyMap","dataTreeDiff","allAddedPaths","getAllPaths","isDynamicLeaf","entityPathDependencies","extractDependencyErrors","entityDependencyMap","pathDependencies","allDeletedPaths","removeNodes","deletedPath","pathsThatDependOnDeletedPath","getDependents","entityId","fullpath","diffCalcEnd","updateChangedDependenciesStart","updateChangedDependenciesStop","diffCalcDeps","updateChangedDependencies","inverseDependencies","updateTreeWithData","tree","dataStore","functionName","DataTreeEvaluator","setPrevState","state","prevState","getPrevState","widgetConfigMap","allActionValidationConfig","DependencyMap","unParsedEvalTree","privateWidgets","console","userLogs","undefinedEvalValuesMap","hasCyclicalDependency","getEvalProps","setEvalTree","getConfigTree","setConfigTree","getUnParsedEvalTree","setUnParsedEvalTree","getOldUnevalTree","setupFirstTree","webworkerTelemetry","totalFirstTreeSetupStartTime","firstCloneStartTime","firstCloneEndTime","parseJSActionsStartTime","parsedCollections","parseJSActionsEndTime","localUnEvalTreeJSCollection","stringifiedLocalUnEvalTreeJSCollection","convertJSFunctionsToString","unEvalTreeWithStrigifiedJSFunctions","allKeysGenerationStartTime","appComputationCache","allKeysGenerationEndTime","createDependencyMapStartTime","webworkerSpans","allAppsmithInternalFunctions","AppsmithFunctionsWithFields","setterFunctions","dependencyMapCache","shouldCache","entityDependencies","createDependencyMap","createDependencyMapEndTime","sortDependenciesStartTime","sortDependenciesEndTime","secondCloneStartTime","secondCloneEndTime","totalFirstTreeSetupEndTime","timeTakenForSetupFirstTree","total","clone","evalOrder","validatedTree","option","validationPathsMap","validationConfig","evalAndValidateFirstTree","evaluationStartTime","evaluationOrder","unEvalTreeClone","klonaJSON","evalMetaUpdates","evaluatedTree","staleMetaIds","evaluateTree","evaluationEndTime","timeTakenForEvalAndValidateFirstTree","evaluation","updateUnEvalTreeJSFunction","unEvalJSCollection","updates","generateJSObjectUpdates","oldUnEvalTreeJSCollections","jsDifferences","convertMicroDiffToDeepDiff","microDiff","jsTranslatedDiffs","_flatten","translateDiffEventToDataTreeDiffEvent","updatedUnEvalTree","stringifiedOldUnEvalTreeJSCollections","oldUnEvalTreeWithStringifiedJSFunctions","unEvalTreeWithStringifiedJSFunctions","setupUpdateTree","actionDataPayloadConsolidated","updatedUnEvalTreeJSFunction","updatedUnEvalTreeJSObjects","unEvalUpdates","isNewWidgetAdded","DataStore","getAllPathsBasedOnDiffPaths","pathsChangedSet","dataPath","_isArray","updatedValuePaths","updateEvalTreeWithChanges","setupUpdateTreeOutput","pathsToSkipFromEval","setupTree","getEvaluationOrder","subTreeSortOrder","unEvalPropValue","evalPropValue","extraParams","calculateSortOrderStartTime","calculateSubTreeSortOrder","calculateSortOrderEndTime","updatedDependencies","removedPath","cloneStartTime","cloneEndTime","timeTakenForSetupUpdateTree","setupUpdateTreeWithDifferences","evalAndValidateSubTree","unevalUpdates","metaWidgetIds","contextTree","newEvalTree","isFirstTree","metaWidgets","timeTakenForEvalAndValidateSubTree","getCompleteSortOrder","changes","inverseMap","subSortOrderArray","finalSortOrder","computeSortOrder","parents","visitedNodes","getEvaluationSortOrder","getImmediateParentsOfPropertyPaths","_difference","uniqueKeysInSortOrder","sortOrderPropertyPaths","completeSortOrder","finalSortOrderArray","lastIndexOf","sortOrder","iterator","newNodes","toBeEvaluatedNode","getPrivateWidgets","safeTree","getDataStore","dataStoreClone","updateAsyncFunctions","allNewEntityDiffSet","release_evaluation_scope_cache","isPropertyAnEntityAction","isADynamicBindingPath","isAPathDynamicBindingPath","requiresEval","contextData","getDynamicValue","EVAL_PROPERTY_ERROR","updateUndefinedEvalValuesMap","isNewWidget","isNewEntity","parsedValue","getParsedValueForWidgetProperty","currentTree","getStaleMetaStateIds","_this$allActionValida","_this$allActionValida2","configProperty","prevEvaluatedValue","prevUnEvalValue","getPrevUnEvalState","skipVariableValueAssignment","_isEqual","evalValue","valueForSafeTree","setPrevUnEvalState","unEvalValue","EVAL_TREE_ERROR","replaceDataStore","setAllActionValidationConfig","pluginType","logToSentry","val","CYCLICAL_DEPENDENCY_ERROR","logError","CrashingError","dynamicBinding","callBackData","index","toBeSentForEval","triggerMeta","triggerPropertyName","onPageLoad","evaluateDynamicBoundValue","isAnyJSAction","addRootcauseToAsyncInvocationErrors","evaluateTriggers","callbackData","isDynamic","isJSObject","evalResponse","overwriteObj","overrideWidgetProperties","overwriteParsedValue","newValue","_messages$map2","text","_ref6","d","applyChange","changePaths","pathArray","isNotEntity","entityDynamicBindingPathsSet","changePathsWithNestedDependants","addDependantsOfNestedPropertyPaths","trimmedChangedPaths","trimDependantChangePaths","evaluateActionBindings","executionParams","evaluatedExecutionParams","generateOverrideContext","replacedBinding","EXECUTION_PARAM_KEY","clearErrors","clearLogs","prevJSUpdates","getVariableObject","prevJSObjects","prevJSObjectVar","jsObjectBody","_jsObjectBody$parsedB","varKeyMap","getJSVariableCreatedEvents","jsVarDiff","jsObjectVar","deepDiff","getVariableDiff","jsVarsCreated","_diff$path","_diff$path2","replayMap","CANVAS","canvasWidgetsMeta","metaWidgetsCache","canvasWidgets","request","_dataTreeEvaluator3","isCreateFirstTree","forceEvaluation","shouldReplay","shouldRespondWithLogs","theme","__unevalTree__","widgetsMeta","widgetTypeConfigMap","isNewTree","__spanAttributes","_replayMap$CANVAS","setupFirstTreeResponse","description","dataTreeResponse","makeEntityConfigsAsObjProperties","_replayMap$CANVAS2","updateActionsToEvalTree","setupUpdateTreeResponse","updateResponse","init","_replayMap$CANVAS3","_replayMap$CANVAS4","_replayMap$CANVAS5","_dataTreeEvaluator","UNKNOWN_ERROR","getSafeToRenderDataTree","sanitizeDataTree","jsVarsCreatedEvent","evalTreeResponse","_dataTreeEvaluator2","serialiseToBigInt","allUnevalUpdates","completeEvalOrder","uniqueOrderUpdatePaths","generateOptimisedUpdatesAndSetPrevState","evalTreeTransmissionErrorHandler","messageId","responseData","sanitizedData","sendMessage","call","messageType","MessageType","RESPONSE","clearCache","ConditionType","FormDataPaths","finalEvalObj","evalConfigPaths","MATCH_ACTION_CONFIG_PROPERTY","matchExact","r","str","generateInitialEvalState","formConfig","conditionals","conditionTypes","configPropertyPath","staticDependencyPathList","dependencyPaths","identifier","allConditionTypes","HIDE","SHOW","_formConfig$condition","_formConfig$condition2","visible","_merge","showOrHideDependencies","show","hide","ENABLE","DISABLE","_formConfig$condition3","_formConfig$condition4","enabled","enableOrDisableDependencies","enable","disable","FETCH_DYNAMIC_VALUES","_formConfig$condition5","_formConfig$condition6","fetchDynamicValuesDependencies","fetchDynamicValues","condition","dynamicDependencyPathList","dynamicValues","allowedToFetch","isLoading","hasStarted","hasFetchFailed","evaluatedConfig","generateEvalFormConfigPaths","_uniq","evaluateFormConfig","updateEvaluatedConfig","evaluateFormConfigObject","extractEvalConfigFromFormConfig","children","schema","parentKey","configToBeChecked","placeholderText","placeHolderText","isTrueObject","evaluateDynamicValuesConfig","actionConfiguration","configArray","evaluatedValue","eval","evaluateFormConfigElements","editorContextType","datasourceConfiguration","expression","evaluatedVal","output","evaluate","currentEvalState","actionDiffPath","hasRouteChanged","conditionBlock","conditionType","_currentEvalState$key","_currentEvalState$key2","_currentEvalState$key3","_currentEvalState$key4","_currentEvalState$key5","_currentEvalState$key6","_currentEvalState$key7","isActionDiffADependency","EVALUATE_FORM_CONFIG","getFormEvaluation","formId","currentFormIdEvalState","conditionToBeEvaluated","dynamicConditionsToBeFetched","_value$staticDependen","COMMAND","setFormEvaluationSaga","ReduxActionTypes","INIT_FORM_EVALUATION","editorConfig","settingConfig","PAGE","DATA_BIND_REGEX_GLOBAL","window","module","exports","setterMethodLookup","setterAccessorMap","applySetterMethod","setterMethodName","updatedProperties","overriddenProperties","shouldUpdateGlobalContext","propPath","resolve","evalTreeWithChanges","metaUpdates","method","EVAL_TREE_WITH_CHANGES","createSetter","getMap","getSetterAccessorMap","setterMethodMap","__setters","pathToSet","configTreeEntries","evaluateAndPushResponse","additionalPathsAddedAsUpdates","response","evaluateAndGenerateResponse","pushResponseToMainThread","defaultResponse","workerResponse","additionalUpdates","getNewDataTreeUpdates","affectedNodePaths","getAffectedNodesInTheDataTree","DEFAULT","UPDATE_DATATREE","t","comments","token","sourceType","SourceType","onComment","onToken","ranges","attachComments","parsedObjectProperties","JSObjectProperties","declaration","properties","propertyKey","rawContent","loc","column","startLine","startColumn","endLine","endColumn","keyStartLine","keyEndLine","keyStartColumn","keyEndColumn","PluginType","API","apiActionSettingsConfig","DB","queryActionSettingsConfig","SAAS","saasActionSettingsConfig","REMOTE","JS","AI","INTERNAL","EXTERNAL_SAAS","apiActionEditorConfig","apiActionDependencyConfig","apiActionDatasourceFormButtonConfig","APPSMITH","CE_ENTITY_TYPE","MODULE_INPUT","MODULE_INSTANCE","platformFns","entityFns","navigateTo","showAlert","showModal","closeModal","download","postWindowMessage","copyToClipboard","resetWidget","storeValue","removeValue","clearStore","isRunNClearFnQualifierEntity","isAppsmithEntity","getGeoLocation","watchGeoLocation","stopWatchGeoLocation","PatchType","setResolvedFunctions","prevUnEvalState","variableValue","newVarState","jsObject","getVariablesForEvaluationContext","cachedJSVariablesByEntityName","varState","newJSObject","varValue","variable","TriggerEmitter","emit","BatchKey","process_js_variable_updates","GET","SET","UNDEFINED_ACTION_IN_SYNC_EVAL_ERROR","asyncFunctionsNameMap","asyncJSFunctionsNames","isViewMode","allAsyncEntityFunctions","modifiers","getErrorMessage","asynFns","setAsyncInvocationErrorsRootcause","asyncFunc","_error$kind","ACTION_INVOCATION_IN_DATA_FIELD","isActionInvokedInDataField","updatedErrors","reachableAsyncJSFunctions","replaceAll","getErrorMessageWithType","UNDEFINED_TYPE_ERROR_REGEX","asyncFunctionFullPath","functionNameWithWhiteSpace","matchedString","undefinedProperty","allMemberExpressionObjects","possibleCauses","objectString","topLevelEntity","at","possibleCausesArr","log","Sentry","convertAllDataTypesToString","postMessage","arrPath","string","Number","isInteger","indexOfFirstDot","translateCollectionDiffs","dataTreeDiffs","idx","diffKey","difference","NOOP","isJsAction","rhsChange","lhsChange","dataTreeDeleteDiffs","_isNil","parentPaths","withNestedPaths","dependantNodes","dependantNodePath","_","removeFunctions","removeFunctionsAndSerialzeBigInt","propertyPaths","records","tempKey","newResult","curr","newDataSegments","trimmedPaths","foundADependant","dependants","dependantPath","entityKey","safeToRenderEntity","derivedProperties","isPrivateEntityPath","getAllPrivateWidgetsInDataTree","logBlackList","errorPath","existingErrors","existingErrorsExceptValidation","prototype","propPathEls","relativePropertyPath","propertyOverrideDependency","overriddenPropertyKey","overridingPropertyKeyMap","existingDependenciesSet","META","configEntity","overridingPropertyPaths","clonedValue","pathsNotToOverride","widgetPathsNotToOverride","overriddenPropertyPath","overriddenPropertyPathArray","metaPropertyPath","propertyOverridingKeyMap","clonedDefaultValue","overriddenPropertyPaths","isMetaPropDirty","overriddenMetaPaths","isWidgetDefaultPropertyPath","isMetaWidgetTemplate","siblingMetaWidgets","jscollections","collections","collectionName","jsFunctions","funcName","_has","actionNames","microDiffDifferences","microDifference","oldValue","setActionData","getActionData","deleteActionData","deletedPathString","extractExpressionObject","parentPath","expressions","completePath","exp","bindingsFound","APPSMITH_GLOBAL_FUNCTIONS","APPSMITH_NAMESPACED_FUNCTIONS","EE_APPSMITH_NAMESPACED_FUNCTIONS","require","ID_EXTRACTION_REGEX","BUILDER_VIEWER_PATH_PREFIX","BUILDER_PATH","API_EDITOR_BASE_PATH","API_EDITOR_ID_PATH","QUERIES_EDITOR_BASE_PATH","QUERIES_EDITOR_ID_PATH","JS_COLLECTION_EDITOR_PATH","JS_COLLECTION_ID_PATH","_nodes","_classPrivateFieldLooseKey","_dependencies","_dependenciesInverse","_invalidDependencies","_invalidDependenciesInverse","_this","_classPrivateFieldLooseBase","validDependencies","invalidDependencies","dependency","_classPrivateFieldLoo","_classPrivateFieldLoo2","previousNodeDependencies","newNodeDependencies","removedNodeDependencies","removedDependency","_classPrivateFieldLoo3","previousNodeInvalidDependencies","newNodeInvalidDependencies","removedNodeInvalidDependencies","removedInvalidDependency","_classPrivateFieldLoo4","removeDependency","didUpdateDependencies","directDependenciesOfNode","directDependency","_classPrivateFieldLoo5","nodes","nodesToAdd","sort","desc","didUpdateGraph","newNode","nodesThatAlreadyDependedOnThis","invalidNode","dependant","_classPrivateFieldLoo6","iNode","_classPrivateFieldLoo7","_classPrivateFieldLoo8","_classPrivateFieldLoo9","_classPrivateFieldLoo10","_classPrivateFieldLoo11","_classPrivateFieldLoo12","isRelated","targets","visited","queue","shift","n","fromEntries","inverseInvalidDependencies","reachableNodes","defaultLibImplementations","lodash","moment","forge","getTernDocType","ignoredKeys","makeTernDefs","defs","cachedDefs","visitedReferences","iteration_count","baseObjPrototype","getPrototypeOf","src","target","getOwnPropertyNames","LibraryInstallError","ImportError","url","TernDefinitionError","generateUniqueAccessor","urlOrName","takenAccessors","takenNamesMap","_name","urlPathParts","URL","pathname","validVar","flattenModule","default","libModule","create","movetheDefaultExportedLibraryToAccessorKey","diffAccessors","uniqAccessor","ReplayEditor","getChanges","isEmpty","modifiedProperty","_internalSetTimeout","_internalClearTimeout","clearTimeout","cb","timerId","_originalFetch","fetch","Request","credentials","initLocalStorage","localStorage","appsmith","overrideWebAPIs","overrideConsoleAPI","syncHandlerMap","EVAL_ACTION_BINDINGS","cleanValues","UNDO","replayResult","REDO","UPDATE_REPLAY_OBJECT","replayObject","VALIDATE_PROPERTY","UNINSTALL_LIBRARY","LINT_TREE","noop","SETUP","documentMock","dom","document","setupDOM","CLEAR_CACHE","SET_EVALUATION_VERSION","INIT_FORM_EVAL","UPDATE_ACTION_DATA","updateActionData","asyncHandlerMap","EVAL_TREE","EVAL_TRIGGER","dynamicTrigger","eventType","EVAL_EXPRESSION","LOAD_LIBRARIES","defaultLibraryAccessors","library","resetJSLibraries","libs","libStore","accessors","keysBefore","importScripts","keysAfter","defaultAccessors","keysAfterDefaultOperation","k","import","flattenedModule","INSTALL_LIBRARY","tempDataTreeStore","removeDataTreeFromContext","dataTreeEntityNames","envKeysBeforeInstallation","unsetLibraryKeys","keysAfterInstallation","differentiatingKeys","uniqueName","addTempStoredDataTreeToContext","transmissionErrorHandlerMap","addEventListener","REQUEST","messageHandler","transmissionErrorHandler","WorkerMessenger","respond","preventDefault","reason","jsObjectProperty","updatePaths","segmentedPath","findDuplicateIndex","_uniqSet","currSetSize","countOccurrences","subString","allowOverlapping","maxLimit","pos","step","stringifyFnsInObject","userObject","parseFunctionsInObject","fnStrings","fnValue","parsedFnString","constructPath","existingPath","suffix","arrayValue","isLargeCollection","rowSize","getReducedDataTree","constrainedDiffPaths","withErrors","_widgetValue$__evalua","widgetValue","__evaluation__","generateOptimisedUpdates","oldDataTree","generateDiffUpdates","attachDirectly","oldData","newData","isMoment","isLhsLarge","isRhsLarge","equal","correctedUpdates","correctUndefinedUpdatesToDeletesOrNew","rootCollectionUpdates","generateRootWidgetUpdates","newDataTree","pathCopy","scrubedOutUpdates","getScrubbedOutUpdatesWhenRootCollectionIsUpdated","rootCollectionPaths","_update$path","condensedPath","mergeAdditionalUpdates","serialisedUpdates","generateSerialisedUpdates","currentState","removedLhs","SERIALIZATION_ERROR","isEnabled","emitter","getSource","_triggerMeta$source","_triggerMeta$source2","_triggerMeta$source3","saveLog","_this$emitter","parseLogs","debug","info","table","warn","_len2","_key2","apply","_len3","_key3","_len4","_key4","_len5","_key5","_len6","_key6","replaceFunctionWithNamesFromObjects","sanitizeData","uuid4","INFO","stack","WARNING","handleActionsDataUpdate","actionsToUpdate","actionToUpdate","dataPathRef","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","m","x","__webpack_exports__","O","amdO","deferred","chunkIds","priority","notFulfilled","Infinity","fulfilled","j","every","splice","getter","__esModule","leafPrototypes","getProto","mode","ns","def","definition","o","f","chunkId","promises","u","miniCssF","g","globalThis","prop","Symbol","toStringTag","nmd","oldGetScript","oldLoadScript","queryMap","countMap","catch","retries","realSrc","location","href","retryAttempt","cacheBust","installedChunks","chunkLoadingGlobal","parentChunkLoadingFunction","moreModules","runtime","nc","next"],"sourceRoot":""}