@wavemaker-ai/react-runtime 1.0.0-rc.309

package/utils/widget-cleanup-util.js

@@ -0,0 +1,109 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWidgetCleanup = void 0;
+exports.removeWidgetsFromContext = removeWidgetsFromContext;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Removes widgets from page context, cleans up registry, and returns the new context.
+ * Returns prev unchanged if no widgets were present.
+ *
+ * @param prev - Current page context
+ * @param names - Widget names to remove
+ * @returns New context with widgets removed, or prev if no changes
+ */
+function removeWidgetsFromContext(context, proxy, names) {
+  var widgets = context === null || context === void 0 ? void 0 : context.Widgets;
+  if (!widgets) return context;
+  var hasChanges = names.some(function (name) {
+    return name in widgets;
+  });
+  if (!hasChanges) return context;
+  var registry = context === null || context === void 0 ? void 0 : context.overriddenPropsRegistry;
+  names.forEach(function (name) {
+    delete context.Widgets[name];
+    proxy.Widgets[name] = null;
+    if (registry) registry.destroy(name);
+  });
+  return context;
+}
+
+/**
+ * Configuration for the widget cleanup utility
+ */
+
+/**
+ * Creates a debounced widget cleanup utility function
+ * This eliminates code duplication between WidgetProvider and BasePage
+ *
+ * @param config - Configuration object for the cleanup utility
+ * @returns Object containing cleanup function and cleanupRef
+ */
+var createWidgetCleanup = exports.createWidgetCleanup = function createWidgetCleanup(config) {
+  var setPageContext = config.setPageContext,
+    proxyRef = config.proxyRef,
+    _config$debounceDelay = config.debounceDelay,
+    debounceDelay = _config$debounceDelay === void 0 ? 100 : _config$debounceDelay;
+  var cleanupRef = new Set();
+  var timeoutId = null;
+
+  // Debounced cleanup function that processes accumulated widget names
+  var performCleanup = function performCleanup() {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(function () {
+      if (cleanupRef.size === 0) return;
+      setPageContext(function (currentContext) {
+        var newContext = _objectSpread({}, currentContext);
+        var widgetsToClean = (0, _toConsumableArray2["default"])(cleanupRef);
+        widgetsToClean.forEach(function (name) {
+          if (newContext.Widgets && newContext.Widgets[name]) {
+            var _proxyRef$current;
+            delete newContext.Widgets[name];
+
+            // Delete from proxy if available
+            if (proxyRef !== null && proxyRef !== void 0 && (_proxyRef$current = proxyRef.current) !== null && _proxyRef$current !== void 0 && _proxyRef$current.Widgets) {
+              delete proxyRef.current.Widgets[name];
+            }
+          }
+        });
+        cleanupRef.clear();
+        return newContext;
+      });
+      timeoutId = null;
+    }, debounceDelay);
+  };
+
+  /**
+   * Cleanup function to be called when a widget needs to be removed
+   * @param name - Name of the widget to cleanup
+   */
+  var cleanup = function cleanup(name) {
+    // Accumulate widget names to be cleaned up
+    cleanupRef.add(name);
+    // Trigger debounced cleanup
+    performCleanup();
+  };
+
+  /**
+   * Cancel any pending cleanup operations
+   */
+  var cancel = function cancel() {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return {
+    cleanup: cleanup,
+    cleanupRef: cleanupRef,
+    cancel: cancel
+  };
+};

package/utils/widgets.d.ts

@@ -0,0 +1,3 @@
+export declare const getObjValueByKey: (obj: any, strKey: string) => any;
+export declare const checkIsCustomPipeExpression: (exp: any) => any;
+export declare const getEvaluatedData: (dataObj: any, options: any, context?: any) => any;

package/utils/widgets.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getObjValueByKey = exports.getEvaluatedData = exports.checkIsCustomPipeExpression = void 0;
+var _lodashEs = require("lodash-es");
+var getObjValueByKey = exports.getObjValueByKey = function getObjValueByKey(obj, strKey) {
+  if (!strKey || !obj) {
+    return obj;
+  }
+  return (0, _lodashEs.get)(obj, strKey);
+};
+var checkIsCustomPipeExpression = exports.checkIsCustomPipeExpression = function checkIsCustomPipeExpression(exp) {
+  var customRegEx = /(custom(\s*:))/g;
+  var matches = exp.match(customRegEx);
+  return matches && matches.length;
+};
+var getEvaluatedData = exports.getEvaluatedData = function getEvaluatedData(dataObj, options, context) {
+  var displayExpr = options.expression;
+  if (displayExpr) {
+    if (typeof displayExpr !== "function") {
+      return dataObj[displayExpr];
+    }
+    return displayExpr(dataObj);
+  }
+  var expressionValue = "";
+  var field = options.field || "",
+    expr = options.expression,
+    bindExpr = options.bindExpression;
+  if (bindExpr) {
+    expressionValue = bindExpr.replace("bind:", "");
+    if (checkIsCustomPipeExpression(expressionValue)) {
+      expressionValue = expressionValue + ": __1";
+    }
+    expressionValue = getUpdatedExpr(expressionValue);
+  } else {
+    expressionValue = expr ? expr : field;
+  }
+  if (!bindExpr && !expr) {
+    if (typeof field === "function") {
+      return field(dataObj);
+    }
+    return (0, _lodashEs.get)(dataObj, field);
+  }
+  return expressionValue;
+};
+var getUpdatedExpr = function getUpdatedExpr(expr) {
+  var updated = "",
+    ch,
+    next,
+    i,
+    j,
+    matchCh,
+    matchCount,
+    isQuotedStr,
+    subStr,
+    isQuotedStrEvaluated;
+  expr = expr.replace(/\$\[data\[\$i\]/g, "$[__1");
+  for (i = 0; i < expr.length; i++) {
+    ch = expr[i];
+    next = expr[i + 1];
+    if (ch === "$" && next === "[") {
+      matchCount = 1;
+      isQuotedStrEvaluated = false;
+      isQuotedStr = false;
+      for (j = i + 2; j < expr.length; j++) {
+        matchCh = expr[j];
+        if (matchCh === " ") {
+          continue;
+        }
+        if (!isQuotedStrEvaluated) {
+          isQuotedStr = expr[j] === '"' || expr[j] === "'";
+          isQuotedStrEvaluated = true;
+        }
+        if (matchCh === "[") {
+          matchCount++;
+        } else if (matchCh === "]") {
+          matchCount--;
+        }
+        if (!matchCount) {
+          subStr = expr.substring(i + 2, j);
+          if (isQuotedStr) {
+            updated += "__1[" + subStr + "]";
+          } else {
+            updated += subStr;
+          }
+          break;
+        }
+      }
+      i = j;
+    } else {
+      updated += ch;
+    }
+  }
+  return updated;
+};

package/variables/base-variable.d.ts

@@ -0,0 +1,61 @@
+import EventNotifier from "@wavemaker-ai/react-runtime/core/event-notifier";
+export interface VariableConfig {
+    name: string;
+    paramProvider: Function;
+    onBefore: Function;
+    onComplete: Function;
+    onSuccess: Function;
+    onError: Function;
+    isList: boolean;
+    twoWayBinding: boolean;
+    service: any;
+    operation: string;
+    operationId: string;
+    operationType: string;
+    serviceType: string;
+    spinnerMessage?: string;
+    spinnerContext?: string;
+    _id: string | number;
+    _context?: any;
+    dataBinding?: any;
+    isStaticParams?: boolean;
+}
+/**
+ * Call at the top of every invokeOnParamChange implementation.
+ * Returns a resolved Promise (early exit) when all dataBinding entries are
+ * static literals so auto-invocation is skipped, or null to continue.
+ */
+export declare function isStaticParamVariable<T>(config: Pick<VariableConfig, "isStaticParams">, instance: T): Promise<T> | null;
+export declare enum VariableEvents {
+    BEFORE_INVOKE = "beforeInvoke",
+    SUCCESS = "success",
+    ERROR = "error",
+    AFTER_INVOKE = "afterInvoke"
+}
+export declare abstract class BaseVariable<T extends VariableConfig> extends EventNotifier {
+    config: T;
+    name: string;
+    params: any;
+    dataSet: any;
+    isList: boolean;
+    twoWayBinding: boolean;
+    isExecuting: boolean;
+    dataBinding: any;
+    constructor(config: T);
+    invoke(params?: {}, onSuccess?: Function, onError?: Function): Promise<BaseVariable<T>>;
+    doNext(): Promise<BaseVariable<T>>;
+    invokeOnParamChange(): Promise<BaseVariable<T>>;
+    getData(): any;
+    setData(dataSet: any): any;
+    getValue(key: string, index: number): any;
+    setValue(key: string, value: any): any;
+    getItem(index: number): any;
+    setItem(index: any, value: any, options?: any): any;
+    addItem(value: any, options?: any): any;
+    removeItem(index: any, options?: any): any;
+    clearData(): any;
+    getCount(): any;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}

package/variables/base-variable.js

@@ -0,0 +1,180 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableEvents = exports.BaseVariable = void 0;
+exports.isStaticParamVariable = isStaticParamVariable;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _datasetUtil = _interopRequireDefault(require("@wavemaker-ai/react-runtime/utils/dataset-util"));
+var _eventNotifier = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/event-notifier"));
+var _lodashEs = require("lodash-es");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+/**
+ * Call at the top of every invokeOnParamChange implementation.
+ * Returns a resolved Promise (early exit) when all dataBinding entries are
+ * static literals so auto-invocation is skipped, or null to continue.
+ */
+function isStaticParamVariable(config, instance) {
+  return config.isStaticParams ? Promise.resolve(instance) : null;
+}
+var VariableEvents = exports.VariableEvents = /*#__PURE__*/function (VariableEvents) {
+  VariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  VariableEvents["SUCCESS"] = "success";
+  VariableEvents["ERROR"] = "error";
+  VariableEvents["AFTER_INVOKE"] = "afterInvoke";
+  return VariableEvents;
+}({});
+var BaseVariable = exports.BaseVariable = /*#__PURE__*/function (_EventNotifier) {
+  function BaseVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, BaseVariable);
+    _this = _callSuper(this, BaseVariable);
+    _this.config = config;
+    (0, _defineProperty2["default"])(_this, "name", "");
+    (0, _defineProperty2["default"])(_this, "params", {});
+    (0, _defineProperty2["default"])(_this, "dataSet", {});
+    (0, _defineProperty2["default"])(_this, "isList", void 0);
+    (0, _defineProperty2["default"])(_this, "twoWayBinding", void 0);
+    (0, _defineProperty2["default"])(_this, "isExecuting", false);
+    (0, _defineProperty2["default"])(_this, "dataBinding", {});
+    _this.name = config.name;
+    _this.isList = config.isList;
+    _this.twoWayBinding = config.twoWayBinding;
+    _this.dataSet = _this.isList ? [] : _this.dataSet;
+    _this.subscribe(VariableEvents.BEFORE_INVOKE, function () {
+      _this.isExecuting = true;
+      console.info("Before Invoking variable ".concat(_this.name));
+    });
+    _this.subscribe(VariableEvents.AFTER_INVOKE, function () {
+      _this.isExecuting = false;
+      console.info("After Invoking variable ".concat(_this.name));
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(BaseVariable, _EventNotifier);
+  return (0, _createClass2["default"])(BaseVariable, [{
+    key: "invoke",
+    value: function invoke(params, onSuccess, onError) {
+      if (!params) {
+        this.params = this.config.paramProvider();
+      } else {
+        this.params = params;
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "doNext",
+    value: function doNext() {
+      return Promise.reject(this);
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange() {
+      var last = this.params;
+      var latest = this.config.paramProvider();
+      if (!(0, _lodashEs.isEqual)(last, latest)) {
+        return this.invoke(latest);
+      }
+      return Promise.resolve(this);
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
+      return this.dataSet;
+    }
+  }, {
+    key: "setData",
+    value: function setData(dataSet) {
+      if (_datasetUtil["default"].isValidDataset(dataSet, this.isList)) {
+        this.dataSet = dataSet;
+      }
+      return this.dataSet;
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(key, index) {
+      return _datasetUtil["default"].getValue(this.dataSet, key, index, this.isList);
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(key, value) {
+      return _datasetUtil["default"].setValue(this.dataSet, key, value, this.isList);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(index) {
+      return _datasetUtil["default"].getItem(this.dataSet, index, this.isList);
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(index, value, options) {
+      options = _datasetUtil["default"].getChildDetails(this.dataSet, options, this.isList);
+      return _datasetUtil["default"].setItem(this.dataSet, index, value, options);
+    }
+  }, {
+    key: "addItem",
+    value: function addItem(value, options) {
+      var index;
+      if ((0, _lodashEs.isNumber)(options)) {
+        index = options;
+      }
+      if ((0, _lodashEs.isObject)(options)) {
+        // @ts-ignore
+        index = options.index;
+      }
+      options = _datasetUtil["default"].getChildDetails(this.dataSet, options, this.isList);
+      return _datasetUtil["default"].addItem(this.dataSet, value, index, options);
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(index, options) {
+      var exactMatch, parentIndex;
+      if (options) {
+        if ((0, _lodashEs.isBoolean)(options)) {
+          exactMatch = options;
+        }
+        if ((0, _lodashEs.isObject)(options)) {
+          // @ts-ignore
+          exactMatch = options.exactMatch;
+          if (this.isList) {
+            // @ts-ignore
+            parentIndex = options.parentIndex || 0;
+          }
+        }
+      }
+      return _datasetUtil["default"].removeItem(this.dataSet, index, {
+        exactMatch: exactMatch,
+        path: (0, _lodashEs.get)(options, "path"),
+        parentIndex: parentIndex
+      });
+    }
+  }, {
+    key: "clearData",
+    value: function clearData() {
+      this.dataSet = _datasetUtil["default"].getValidDataset(this.isList);
+      return this.dataSet;
+    }
+  }, {
+    key: "getCount",
+    value: function getCount() {
+      return _datasetUtil["default"].getCount(this.dataSet, this.isList);
+    }
+  }, {
+    key: "pause",
+    value: function pause() {}
+  }, {
+    key: "resume",
+    value: function resume() {}
+  }, {
+    key: "destroy",
+    value: function destroy() {}
+  }]);
+}(_eventNotifier["default"]);

package/variables/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const WS_CONSTANTS: {
+    NON_BODY_HTTP_METHODS: string[];
+    NON_DATA_AXIOS_METHODS: string[];
+    CONTENT_TYPES: {
+        FORM_URL_ENCODED: string;
+        MULTIPART_FORMDATA: string;
+        OCTET_STREAM: string;
+    };
+    REST_SERVICE: {
+        ERR_TYPE: {
+            METADATA_MISSING: string;
+            CRUD_OPERATION_MISSING: string;
+            USER_UNAUTHORISED: string;
+        };
+        ERR_MSG: {
+            METADATA_MISSING: string;
+            USER_UNAUTHORISED: string;
+            CRUD_OPERATION_MISSING: string;
+        };
+    };
+};

package/variables/constants.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WS_CONSTANTS = void 0;
+var WS_CONSTANTS = exports.WS_CONSTANTS = {
+  NON_BODY_HTTP_METHODS: ["GET", "HEAD"],
+  NON_DATA_AXIOS_METHODS: ["GET", "DELETE", "HEAD", "OPTIONS"],
+  CONTENT_TYPES: {
+    FORM_URL_ENCODED: "application/x-www-form-urlencoded",
+    MULTIPART_FORMDATA: "multipart/form-data",
+    OCTET_STREAM: "application/octet-stream"
+  },
+  REST_SERVICE: {
+    ERR_TYPE: {
+      METADATA_MISSING: "metadata_missing",
+      CRUD_OPERATION_MISSING: "crud_operation_missing",
+      USER_UNAUTHORISED: "user_unauthorised"
+    },
+    ERR_MSG: {
+      METADATA_MISSING: 'Metadata missing for "$variable"',
+      USER_UNAUTHORISED: "Unauthorized User",
+      CRUD_OPERATION_MISSING: 'Operation "$operation" not allowed for "$variable"'
+    }
+  }
+};

package/variables/crud-variable.d.ts

@@ -0,0 +1,39 @@
+import { VariableConfig } from "./base-variable";
+export interface CrudVariableConfig extends VariableConfig {
+    name: string;
+    dataSet: any;
+    inputFields: any;
+    filterExpressions: any;
+    filterFields: any;
+    crudOperationId: string;
+    baseUrl: string;
+    maxResults: number;
+    onCanUpdate: any;
+    onBeforeUpdate: any;
+    onResult: any;
+    onBeforeDatasetReady: any;
+    onError: any;
+    controller: string;
+    dataBinding: Record<string, unknown>;
+    filterProvider?: Function;
+}
+declare const CrudVariable_base: any;
+declare class CrudVariable extends CrudVariable_base {
+    config: CrudVariableConfig;
+    params: any;
+    filters: any;
+    constructor(config: CrudVariableConfig);
+    setFilterExpValue(filter: any): void;
+    invokeOnParamChange(): Promise<this>;
+    listRecords(options?: any, onSuccess?: Function, onError?: Function): any;
+    updateRecord(options?: any, success?: any, error?: any): any;
+    insertRecord(options?: any, success?: any, error?: any): any;
+    deleteRecord(options?: any, success?: any, error?: any): any;
+    processBindExp(d: any, variable: CrudVariable): {
+        name: any;
+        value: any;
+    };
+    processBinding(variable: any): void;
+    invoke(options?: any, onSuccess?: Function, onError?: Function): any;
+}
+export default CrudVariable;