@wavemaker-ai/react-runtime 1.0.0-rc.314 → 1.0.0-rc.317

package/runtime-dynamic/factories/utils.d.ts

@@ -2,7 +2,7 @@ import React from "react";
 import { ScriptScope } from "../services/script-executor";
 import { buildStartupInfo } from "./startup-info";
 import type { TranspileOptions } from "../services/markup-transpiler";
-import type { DecodedFragment } from "../services/cache";
+import type { DecodedFragment } from "../services/component-ref-provider";
 export interface DynamicComponentConfig {
     componentName: string;
     componentType: "page" | "partial" | "prefab";

package/runtime-dynamic/services/component-ref-provider.d.ts

@@ -1,12 +1,27 @@
 import { ComponentType } from "./fragment-url";
-import type { DecodedFragment } from "./cache";
+export interface PageMinJSON {
+    markup: string;
+    script: string;
+    styles: string;
+    variables: string;
+    config?: string;
+    error?: string;
+}
+export interface DecodedFragment {
+    markup: string;
+    script: string;
+    styles: string;
+    variables: Record<string, unknown>;
+    config?: Record<string, unknown>;
+    error?: string;
+}
 export interface GetComponentOptions {
     prefabName?: string;
 }
 export declare function getComponentRef(componentName: string, componentType: ComponentType, options?: GetComponentOptions): Promise<DecodedFragment>;
 export declare function getPrefabConfig(prefabName: string): Promise<Record<string, unknown>>;
 /**
- * Clears fetched fragments, built components, resource HTTP cache, prefab injected assets,
- * transpiled markup cache, and compiled variable factories so the next load rebuilds from disk.
+ * Resets injected prefab assets and transpile/variable caches so the next
+ * load rebuilds from the server.
  */
 export declare function clearComponentRefCache(): void;

package/runtime-dynamic/services/component-ref-provider.js

@@ -1,29 +1,22 @@
 import isString from "lodash-es/isString";
 import { transformEx } from "@wavemaker-ai/react-codegen/transpiler";
-import { fetchResource, clearResourceCache } from "./resource-manager";
+import { fetchResource } from "./resource-manager";
 import { getFragmentUrl, getPrefabConfigUrl } from "./fragment-url";
-import {
-  getFragmentFromCache,
-  setFragmentInCache,
-  deleteFragmentFromCache,
-  clearAllCaches,
-  getPrefabConfigFromCache,
-  setPrefabConfigInCache,
-  deletePrefabConfigFromCache
-} from "./cache";
 import { decodeURIComponentSafe, parseJsonSafe } from "../utils";
 import { clearPrefabResourcesLoaded, loadPrefabResourcesFromConfig } from "./prefab-resources";
 import { clearTranspileCache } from "./markup-transpiler";
 import { clearVariablesCache } from "./variable-transpiler";
-function getOrCreateCachedPromise(get, set, del, key, create) {
-  const existing = get(key);
-  if (existing) return existing;
-  const pending = create();
-  set(key, pending);
-  pending.catch(() => del(key));
-  return pending;
-}
 function decodeFragment(raw) {
+  if (!raw) {
+    return {
+      markup: "",
+      script: "",
+      styles: "",
+      variables: parseJsonSafe("{}"),
+      config: void 0,
+      error: "Access Denied"
+    };
+  }
   return {
     markup: decodeURIComponentSafe(raw.markup || ""),
     script: decodeURIComponentSafe(raw.script || ""),
@@ -34,13 +27,7 @@ function decodeFragment(raw) {
 }
 async function loadFragment(componentName, componentType, prefabName) {
   const url = getFragmentUrl(componentName, componentType, prefabName);
-  return getOrCreateCachedPromise(
-    getFragmentFromCache,
-    setFragmentInCache,
-    deleteFragmentFromCache,
-    url,
-    () => fetchResource(url, true).then(decodeFragment)
-  );
+  return fetchResource(url).then(decodeFragment);
 }
 async function getComponentRef(componentName, componentType, options) {
   return loadFragment(componentName, componentType, options == null ? void 0 : options.prefabName);
@@ -69,21 +56,11 @@ function buildDynamicPrefabProps(result) {
 }
 async function getPrefabConfig(prefabName) {
   const url = getPrefabConfigUrl(prefabName);
-  return getOrCreateCachedPromise(
-    getPrefabConfigFromCache,
-    setPrefabConfigInCache,
-    deletePrefabConfigFromCache,
-    url,
-    async () => {
-      const raw = await fetchResource(url, true);
-      await loadPrefabResourcesFromConfig(prefabName, raw);
-      return buildDynamicPrefabProps(raw);
-    }
-  );
+  const raw = await fetchResource(url);
+  await loadPrefabResourcesFromConfig(prefabName, raw);
+  return buildDynamicPrefabProps(raw);
 }
 function clearComponentRefCache() {
-  clearResourceCache();
-  clearAllCaches();
   clearPrefabResourcesLoaded();
   clearTranspileCache();
   clearVariablesCache();

package/runtime-dynamic/services/index.d.ts

@@ -1,4 +1,4 @@
-export { fetchResource, clearResourceCache } from "./resource-manager";
+export { fetchResource } from "./resource-manager";
 export { ComponentType, getFragmentUrl, getPrefabBaseUrl, getPrefabConfigUrl, isPrefabSelfPreview, } from "./fragment-url";
 export { getComponentRef, clearComponentRefCache } from "./component-ref-provider";
 export { getPrefabResourceUrl } from "./prefab-resources";
@@ -6,5 +6,4 @@ export { buildAddPageScript } from "./script-executor";
 export { transpileAndBuildGetVariables, clearVariablesCache } from "./variable-transpiler";
 export { scopeComponentStyles, removeComponentStyles } from "./css-scoping";
 export { loadAppExtensions } from "./app-extension-provider";
-export type { PageMinJSON, DecodedFragment } from "./cache";
-export { getFragmentFromCache, setFragmentInCache, getComponentFromCache, setComponentInCache, getScriptFromCache, setScriptInCache, clearAllCaches, } from "./cache";
+export type { PageMinJSON, DecodedFragment } from "./component-ref-provider";

package/runtime-dynamic/services/index.js

@@ -1,4 +1,4 @@
-import { fetchResource, clearResourceCache } from "./resource-manager";
+import { fetchResource } from "./resource-manager";
 import {
   ComponentType,
   getFragmentUrl,
@@ -12,37 +12,20 @@ import { buildAddPageScript } from "./script-executor";
 import { transpileAndBuildGetVariables, clearVariablesCache } from "./variable-transpiler";
 import { scopeComponentStyles, removeComponentStyles } from "./css-scoping";
 import { loadAppExtensions } from "./app-extension-provider";
-import {
-  getFragmentFromCache,
-  setFragmentInCache,
-  getComponentFromCache,
-  setComponentInCache,
-  getScriptFromCache,
-  setScriptInCache,
-  clearAllCaches
-} from "./cache";
 export {
   ComponentType,
   buildAddPageScript,
-  clearAllCaches,
   clearComponentRefCache,
-  clearResourceCache,
   clearVariablesCache,
   fetchResource,
-  getComponentFromCache,
   getComponentRef,
-  getFragmentFromCache,
   getFragmentUrl,
   getPrefabBaseUrl,
   getPrefabConfigUrl,
   getPrefabResourceUrl,
-  getScriptFromCache,
   isPrefabSelfPreview,
   loadAppExtensions,
   removeComponentStyles,
   scopeComponentStyles,
-  setComponentInCache,
-  setFragmentInCache,
-  setScriptInCache,
   transpileAndBuildGetVariables
 };

package/runtime-dynamic/services/resource-manager.d.ts

@@ -1,3 +1,2 @@
-export declare function fetchResource<T = unknown>(url: string, useCache?: boolean, optional?: false): Promise<T>;
-export declare function fetchResource<T = unknown>(url: string, useCache: boolean, optional: true): Promise<T | null>;
-export declare function clearResourceCache(): void;
+export declare function fetchResource<T = unknown>(url: string, optional?: false): Promise<T>;
+export declare function fetchResource<T = unknown>(url: string, optional: true): Promise<T | null>;

package/runtime-dynamic/services/resource-manager.js

@@ -1,35 +1,25 @@
 import axios from "axios";
 import { resolvePreviewFetchUrl } from "../preview-resource-base";
 import { handle401 } from "../../core/app.service";
-const cache = /* @__PURE__ */ new Map();
-async function fetchResource(url, useCache = true, optional = false) {
+async function fetchResource(url, optional = false) {
   var _a;
   const resolvedUrl = resolvePreviewFetchUrl(url);
-  if (useCache && cache.has(resolvedUrl)) {
-    return cache.get(resolvedUrl);
-  }
   try {
     const response = await axios.get(resolvedUrl);
-    const { data } = response;
-    if (useCache) {
-      cache.set(resolvedUrl, data);
-    }
-    return data;
+    return response.data;
   } catch (error) {
     if (optional) {
       return null;
     }
     const status = (_a = error == null ? void 0 : error.response) == null ? void 0 : _a.status;
-    if (status === 401 || status === 403) {
+    if (status === 401) {
       handle401();
+    } else if (status === 403) {
+      return null;
     }
     throw error;
   }
 }
-function clearResourceCache() {
-  cache.clear();
-}
 export {
-  clearResourceCache,
   fetchResource
 };

package/runtime-dynamic/services/script-executor.js

@@ -1,7 +1,6 @@
 import * as lodash from "lodash-es";
 import moment from "moment";
 import { Utils } from "../../core/util/utils";
-import { getScriptFromCache, setScriptInCache } from "./cache";
 var ScriptScope = /* @__PURE__ */ ((ScriptScope2) => {
   ScriptScope2["PAGE"] = "Page";
   ScriptScope2["PARTIAL"] = "Partial";
@@ -43,15 +42,12 @@ function prepareScript(raw) {
 function buildAddPageScript(script, scopeKind, componentName) {
   if (!script) return () => {
   };
-  const cacheKey = `${scopeKind}:${componentName}`;
-  const cached = getScriptFromCache(cacheKey);
-  if (cached) return cached;
   try {
     const cleanScript = prepareScript(script);
     const allNames = [...Object.keys(SCRIPT_GLOBALS), ...DEFERRED_GLOBALS];
     const compiledFn = new Function("App", scopeKind, ...allNames, cleanScript);
     const staticValues = Object.keys(SCRIPT_GLOBALS).map((k) => SCRIPT_GLOBALS[k]);
-    const boundFn = (app, page) => {
+    return (app, page) => {
       try {
         const deferredValues = DEFERRED_GLOBALS.map((k) => window[k]);
         compiledFn(app, page, ...staticValues, ...deferredValues);
@@ -62,8 +58,6 @@ function buildAddPageScript(script, scopeKind, componentName) {
         );
       }
     };
-    setScriptInCache(cacheKey, boundFn);
-    return boundFn;
   } catch (compileError) {
     console.error(
       `[script-executor] Compilation error in ${scopeKind} script "${componentName}":`,

package/runtime-dynamic/services/variable-registry.js

@@ -51,15 +51,11 @@ const SCOPE_MAP = {
 const EMPTY_RESULT = { Variables: {}, Actions: {} };
 function createLazyPartial(partialName) {
   return lazy(async () => {
-    const { getComponentFromCache, setComponentInCache } = await import("./cache");
     const { ComponentType: FType } = await import("./fragment-url");
     const { getComponentRef } = await import("./component-ref-provider");
     const { buildBasePageLikeComponent } = await import("../factories/build-base-page-like-component");
-    const cached = getComponentFromCache(FType.PARTIAL, partialName);
-    if (cached) return { default: cached };
     const fragment = await getComponentRef(partialName, FType.PARTIAL);
     const Built = await buildBasePageLikeComponent("partial", partialName, fragment);
-    setComponentInCache(FType.PARTIAL, partialName, Built);
     return { default: Built };
   });
 }

package/utils/attr.js

@@ -4,24 +4,17 @@ const INTERNAL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "conditionalstyle",
   "dataset",
   "destroy",
-  "eventCallback",
   "formfield",
-  "forwardedRef",
   "inbound",
   "iswidget",
-  "listener",
-  "onHeaderclick",
-  "onHeaderClick",
-  "onLoad",
-  "onDestroy",
-  "onNavHeightChange",
   "onRender",
   "outbound",
   "prefab",
   "ref",
   "showindevice",
   "styles",
-  "viewParent"
+  "viewParent",
+  "onLeftPanelAnimationChange"
 ]);
 const SAFE_ATTRIBUTES = /* @__PURE__ */ new Set([
   "accessKey",

package/utils/custom-expression/index.js

@@ -43,7 +43,10 @@ async function buildCustomExpressionComponentsMap(options) {
   const results = await Promise.all(
     keys.map(async (key) => {
       const transformedMarkup = normalizeTransformedMarkupRowBinding(
-        tm(columnSource[key].customExpression)
+        tm(columnSource[key].customExpression, {
+          appUrl: "",
+          insideTableColumn: true
+        })
       );
       const component = await parseFn(transformedMarkup, listener);
       return { key, component };

package/utils/custom-expression/parser.js

@@ -18,8 +18,8 @@ function extractMarkupComponents(markup) {
 }
 function resolveCustomExpressionScope(imports, fragment, markupForInference) {
   const fr = fragment;
-  const names = ["React", "fragment", "row", "Widgets", "Variables"];
-  const values = [React, fragment, void 0, fr == null ? void 0 : fr.Widgets, fr == null ? void 0 : fr.Variables];
+  const names = ["React", "fragment", "row", "rowData", "Widgets", "Variables"];
+  const values = [React, fragment, void 0, void 0, fr == null ? void 0 : fr.Widgets, fr == null ? void 0 : fr.Variables];
   const seen = new Set(names);
   for (const importDef of imports) {
     const binding = importDef.as || importDef.name;
@@ -87,6 +87,7 @@ return __render__();`;
 ${jsxInner}`
   );
   const rowIdx = names.indexOf("row");
+  const rowDataIdx = names.indexOf("rowData");
   const fragmentIdx = names.indexOf("fragment");
   const widgetsIdx = names.indexOf("Widgets");
   const variablesIdx = names.indexOf("Variables");
@@ -110,6 +111,7 @@ ${jsxInner}`
     try {
       const args = templateValues.slice();
       args[rowIdx] = rowData;
+      if (rowDataIdx >= 0) args[rowDataIdx] = rowData;
       const fr = fragment;
       if (fragmentIdx >= 0) args[fragmentIdx] = fragment;
       if (widgetsIdx >= 0) args[widgetsIdx] = fr == null ? void 0 : fr.Widgets;

package/utils/state-persistance.d.ts

@@ -1,5 +1,5 @@
 export type StorageType = "localStorage" | "sessionStorage" | "URL" | "none";
-type WidgetType = "accordion" | "tabs" | "list" | "table";
+type WidgetType = "accordion" | "tabs" | "list" | "table" | "tree";
 interface StateConfig {
     name: string;
     type: WidgetType;

package/runtime-dynamic/services/cache.d.ts

@@ -1,29 +0,0 @@
-import type React from "react";
-import { ComponentType } from "./fragment-url";
-export interface PageMinJSON {
-    markup: string;
-    script: string;
-    styles: string;
-    variables: string;
-    config?: string;
-}
-export interface DecodedFragment {
-    markup: string;
-    script: string;
-    styles: string;
-    variables: Record<string, unknown>;
-    config?: Record<string, unknown>;
-}
-type ScriptFn = (...args: unknown[]) => void;
-export declare const getPrefabConfigFromCache: (url: string) => Promise<Record<string, unknown>> | undefined;
-export declare function setPrefabConfigInCache(url: string, config: Promise<Record<string, unknown>>): void;
-export declare function deletePrefabConfigFromCache(url: string): void;
-export declare const getFragmentFromCache: (url: string) => Promise<DecodedFragment> | undefined;
-export declare function setFragmentInCache(url: string, fragment: Promise<DecodedFragment>): void;
-export declare function deleteFragmentFromCache(url: string): void;
-export declare const getComponentFromCache: (componentType: ComponentType, componentName: string) => React.ComponentType<any> | undefined;
-export declare function setComponentInCache(componentType: ComponentType, componentName: string, component: React.ComponentType<any>): void;
-export declare const getScriptFromCache: (identifier: string) => ScriptFn | undefined;
-export declare function setScriptInCache(identifier: string, scriptFn: ScriptFn): void;
-export declare function clearAllCaches(): void;
-export {};

package/runtime-dynamic/services/cache.js

@@ -1,51 +0,0 @@
-const fragmentCache = /* @__PURE__ */ new Map();
-const componentCache = /* @__PURE__ */ new Map();
-const scriptCache = /* @__PURE__ */ new Map();
-const prefabConfigCache = /* @__PURE__ */ new Map();
-const getPrefabConfigFromCache = (url) => prefabConfigCache.get(url);
-function setPrefabConfigInCache(url, config) {
-  prefabConfigCache.set(url, config);
-}
-function deletePrefabConfigFromCache(url) {
-  prefabConfigCache.delete(url);
-}
-const getFragmentFromCache = (url) => fragmentCache.get(url);
-function setFragmentInCache(url, fragment) {
-  fragmentCache.set(url, fragment);
-}
-function deleteFragmentFromCache(url) {
-  fragmentCache.delete(url);
-}
-const getComponentFromCache = (componentType, componentName) => {
-  var _a;
-  return (_a = componentCache.get(componentType)) == null ? void 0 : _a.get(componentName);
-};
-function setComponentInCache(componentType, componentName, component) {
-  if (!componentCache.has(componentType)) {
-    componentCache.set(componentType, /* @__PURE__ */ new Map());
-  }
-  componentCache.get(componentType).set(componentName, component);
-}
-const getScriptFromCache = (identifier) => scriptCache.get(identifier);
-function setScriptInCache(identifier, scriptFn) {
-  scriptCache.set(identifier, scriptFn);
-}
-function clearAllCaches() {
-  fragmentCache.clear();
-  componentCache.clear();
-  scriptCache.clear();
-  prefabConfigCache.clear();
-}
-export {
-  clearAllCaches,
-  deleteFragmentFromCache,
-  deletePrefabConfigFromCache,
-  getComponentFromCache,
-  getFragmentFromCache,
-  getPrefabConfigFromCache,
-  getScriptFromCache,
-  setComponentInCache,
-  setFragmentInCache,
-  setPrefabConfigInCache,
-  setScriptInCache
-};