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

package/variables/model-variable.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModelVariable = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+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 _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _lodashEs = require("lodash-es");
+var _baseVariable = require("./base-variable");
+var _variables = require("@wavemaker-ai/variables");
+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; }
+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; })(); }
+function _superPropGet(t, o, e, r) { var p = (0, _get2["default"])((0, _getPrototypeOf2["default"])(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } // @ts-ignore
+var ModelVariable = exports.ModelVariable = /*#__PURE__*/function (_ref) {
+  function ModelVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ModelVariable);
+    var initialData = config.paramProvider();
+    var variable = {
+      name: config.name,
+      dataSet: initialData != null ? initialData : config.isList ? [] : {
+        dataValue: ""
+      },
+      isList: config.isList,
+      twoWayBinding: config.twoWayBinding
+    };
+    _this = _callSuper(this, ModelVariable, [variable]);
+    (0, _defineProperty2["default"])(_this, "config", void 0);
+    (0, _defineProperty2["default"])(_this, "lastParams", void 0);
+    (0, _defineProperty2["default"])(_this, "dataSet", void 0);
+    (0, _defineProperty2["default"])(_this, "initialized", false);
+    _this.config = config;
+    _this.invoke();
+    return _this;
+  }
+  (0, _inherits2["default"])(ModelVariable, _ref);
+  return (0, _createClass2["default"])(ModelVariable, [{
+    key: "invoke",
+    value: function invoke(params, onSuccess, onError) {
+      var result;
+      try {
+        var provided = this.config.paramProvider();
+        if (Array.isArray(provided)) {
+          this.dataSet = provided;
+        } else if (this.dataSet && provided) {
+          this.dataSet = Array.isArray(this.dataSet) ? provided : _objectSpread(_objectSpread({}, this.dataSet), provided);
+        } else if (this.dataSet && Object.keys(this.dataSet).length !== 0) {
+          this.dataSet = Array.isArray(this.dataSet) ? (0, _toConsumableArray2["default"])(this.dataSet) : _objectSpread({}, this.dataSet);
+        } else {
+          this.dataSet = provided;
+        }
+        this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [this, this.dataSet]);
+        result = _superPropGet(ModelVariable, "execute", this, 3)([params, function () {}]);
+        this.config.onSuccess && this.config.onSuccess(this, this.dataSet);
+        onSuccess && onSuccess(this, this.dataSet);
+        this.notify(_baseVariable.VariableEvents.SUCCESS, [this, this.dataSet]);
+      } catch (error) {
+        this.config.onError && this.config.onError(this, this.dataSet);
+        onError && onError(this, this.dataSet);
+        this.notify(_baseVariable.VariableEvents.ERROR, [this, this.dataSet]);
+      }
+      this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [this, this.dataSet]);
+      return result;
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function invokeOnParamChange(obj, newVal, oldVal) {
+      var latest = this.config.paramProvider();
+      if (!(0, _lodashEs.isEqual)(this.lastParams, latest)) {
+        this.invoke();
+        this.lastParams = (0, _lodashEs.clone)(latest);
+      }
+      return Promise.resolve(this);
+    }
+  }]);
+}(_variables.ModelVariable);

package/variables/service-variable.d.ts

@@ -0,0 +1,41 @@
+import { VariableConfig, VariableEvents } from "./base-variable";
+export interface ServiceVariableConfig extends VariableConfig {
+    baseUrl: string;
+    maxResults: number;
+    _context: any;
+    serviceType: string;
+    onCanUpdate: any;
+    onBeforeUpdate: any;
+    onResult: any;
+    onBeforeDatasetReady: any;
+    inFlightBehavior: string;
+    controller: string;
+    getServiceInfo: Function;
+}
+declare enum _ServiceVariableEvents {
+    BEFORE_INVOKE = "beforeInvoke"
+}
+export type ServiceVariableEvents = _ServiceVariableEvents | VariableEvents;
+declare const ServiceVariable_base: any;
+export declare class ServiceVariable extends ServiceVariable_base {
+    config: ServiceVariableConfig;
+    pagination: any;
+    private cancelTokenSource;
+    private initialized;
+    params: any;
+    private lastInvokedParams;
+    private dateFormatter;
+    private lastParams;
+    private lastParamProviderValues;
+    private dataBindingRequestBody;
+    constructor(config: ServiceVariableConfig);
+    private updateFirstAndLastRecord;
+    private setupEventHandlers;
+    invokeOnParamChange(obj?: any, newVal?: any, oldVal?: any): Promise<this>;
+    doNext(): Promise<unknown>;
+    onDataUpdated(): void;
+    invoke(options?: any, onSuccess?: Function, onError?: Function): any;
+    setInput(key: any, val?: any, options?: any): any;
+}
+export declare const _setInput: (targetObj: any, key: any, val: any, options?: any) => any;
+export {};

package/variables/service-variable.js

@@ -0,0 +1,356 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._setInput = exports.ServiceVariable = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+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 _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _baseVariable = require("./base-variable");
+var _lodashEs = require("lodash-es");
+var _util = require("@wavemaker-ai/react-runtime/core/util");
+var _variables = require("@wavemaker-ai/variables");
+var _useHttp = require("@wavemaker-ai/react-runtime/hooks/useHttp");
+var _formatUtil = require("../utils/format-util");
+var _eventNotifier = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/event-notifier"));
+var _formatters = _interopRequireDefault(require("@wavemaker-ai/react-runtime/core/formatters"));
+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; })(); }
+function _superPropGet(t, o, e, r) { var p = (0, _get2["default"])((0, _getPrototypeOf2["default"])(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; } // @ts-ignore
+var _ServiceVariableEvents = /*#__PURE__*/function (_ServiceVariableEvents) {
+  _ServiceVariableEvents["BEFORE_INVOKE"] = "beforeInvoke";
+  return _ServiceVariableEvents;
+}(_ServiceVariableEvents || {});
+var ServiceVariable = exports.ServiceVariable = /*#__PURE__*/function (_ref) {
+  function ServiceVariable(config) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ServiceVariable);
+    // Store context in httpService for global access
+    if (config._context) {
+      _useHttp.httpService.setContext(config._context);
+    }
+
+    // Initialize with minimal configuration first
+    var variableConfig = {
+      name: config.name,
+      dataSet: config.paramProvider(),
+      // Default empty value
+      dataBinding: {},
+      firstRecord: {},
+      lastRecord: {},
+      isList: config.isList,
+      service: config.service,
+      serviceType: config.serviceType,
+      maxResults: config.maxResults,
+      _context: config._context,
+      operation: config.operation,
+      operationId: config.operationId,
+      operationType: config.operationType,
+      controller: config.controller,
+      serviceInfo: config.getServiceInfo(),
+      httpClientService: _useHttp.httpService,
+      inFlightBehavior: config.inFlightBehavior,
+      spinnerMessage: config.spinnerMessage,
+      spinnerContext: config.spinnerContext,
+      onSuccess: function onSuccess(context, args) {
+        _this.dataBindingRequestBody(args, _this.lastInvokedParams);
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.SUCCESS, [args.variable, args.data, args.options]);
+        _this.updateFirstAndLastRecord(args.data);
+        return config.onSuccess && config.onSuccess(args.variable, args.data, args.options);
+      },
+      onError: function onError(context, args) {
+        _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.data, args.options]);
+        _this.notify(_baseVariable.VariableEvents.ERROR, [args.variable, args.data, args.options]);
+        if (args.data.includes("Violation")) {
+          _eventNotifier["default"].ROOT.notify("SERVICE_ERROR", [args.variable, args.data, args.options]);
+        }
+        return config.onError && config.onError(args.variable, args.data, args.options);
+      },
+      onCanUpdate: function onCanUpdate(context, args) {
+        return config.onCanUpdate && config.onCanUpdate(args.variable, args.data, args.options);
+      },
+      onBeforeUpdate: function onBeforeUpdate(context, args) {
+        _this.notify(_baseVariable.VariableEvents.BEFORE_INVOKE, [args.variable, args.inputData, args.options]);
+        var userBeforeRet = config.onBeforeUpdate ? config.onBeforeUpdate(args.variable, args.inputData, args.options) : undefined;
+        // When app onBeforeUpdate returns false, the service manager aborts the call without
+        // emitting AFTER_INVOKE; we already notified BEFORE_INVOKE, so UI loading would stick.
+        if (userBeforeRet === false) {
+          _this.notify(_baseVariable.VariableEvents.AFTER_INVOKE, [args.variable, args.inputData, args.options]);
+        }
+        return userBeforeRet;
+      },
+      onResult: function onResult(context, args) {
+        return config.onResult && config.onResult(args.variable, args.data, args.options);
+      },
+      onBeforeDatasetReady: function onBeforeDatasetReady(context, args) {
+        return config.onBeforeDatasetReady && config.onBeforeDatasetReady(args.variable, args.data, args.options);
+      }
+    };
+    _this = _callSuper(this, ServiceVariable, [variableConfig]);
+
+    // Set up event handlers
+    _this.config = config;
+    (0, _defineProperty2["default"])(_this, "pagination", void 0);
+    (0, _defineProperty2["default"])(_this, "cancelTokenSource", void 0);
+    (0, _defineProperty2["default"])(_this, "initialized", false);
+    (0, _defineProperty2["default"])(_this, "params", undefined);
+    (0, _defineProperty2["default"])(_this, "lastInvokedParams", undefined);
+    (0, _defineProperty2["default"])(_this, "dateFormatter", void 0);
+    (0, _defineProperty2["default"])(_this, "lastParams", undefined);
+    (0, _defineProperty2["default"])(_this, "lastParamProviderValues", undefined);
+    _this.setupEventHandlers(config);
+    _this.dateFormatter = _formatters["default"].get("toDate");
+    return _this;
+  }
+  // Method to update firstRecord and lastRecord from the current dataset
+  (0, _inherits2["default"])(ServiceVariable, _ref);
+  return (0, _createClass2["default"])(ServiceVariable, [{
+    key: "dataBindingRequestBody",
+    value: function dataBindingRequestBody(args, invokedParams) {
+      var _invokedParams$Reques;
+      var v = args === null || args === void 0 ? void 0 : args.variable;
+      if (!v) return;
+      v.dataBinding = v.dataBinding || {};
+
+      // Keep both casings for compatibility with app scripts and Angular runtime expectations.
+      // Prefer existing values, otherwise fallback to the request payload used for invocation.
+      var existingBody = v.dataBinding.RequestBody;
+      var payload = (_invokedParams$Reques = invokedParams === null || invokedParams === void 0 ? void 0 : invokedParams.RequestBody) !== null && _invokedParams$Reques !== void 0 ? _invokedParams$Reques : invokedParams;
+      if (existingBody === undefined && payload !== undefined) {
+        v.dataBinding.RequestBody = payload;
+      }
+    }
+  }, {
+    key: "updateFirstAndLastRecord",
+    value: function updateFirstAndLastRecord(data) {
+      try {
+        var dataSet = this.dataSet;
+        var isList = this.isList;
+        if (isList && Array.isArray(dataSet)) {
+          // For list variables, set firstRecord and lastRecord to the actual first and last items
+          this.firstRecord = dataSet.length > 0 ? dataSet[0] : {};
+          this.lastRecord = dataSet.length > 0 ? dataSet[dataSet.length - 1] : {};
+        } else {
+          // For non-list variables, firstRecord and lastRecord are the same as the dataset
+          this.firstRecord = dataSet || {};
+          this.lastRecord = dataSet || {};
+        }
+      } catch (error) {
+        console.error("Error updating firstRecord and lastRecord:", error);
+      }
+    }
+  }, {
+    key: "setupEventHandlers",
+    value: function setupEventHandlers(config) {
+      // Implementation for setting up event handlers
+    }
+  }, {
+    key: "invokeOnParamChange",
+    value: function () {
+      var _invokeOnParamChange = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(obj, newVal, oldVal) {
+        var _this2 = this;
+        var isStatic, currentParams, currentParamProvider, currentDataBinding, paramsChanged, paramProviderChanged, latest, last;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              isStatic = (0, _baseVariable.isStaticParamVariable)(this.config, this);
+              if (!isStatic) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return", isStatic);
+            case 3:
+              // Get current values from all sources
+              currentParams = this.params;
+              currentParamProvider = this.config.paramProvider();
+              currentDataBinding = this.dataBinding; // Detect what CHANGED since last invocation
+              paramsChanged = !(0, _lodashEs.isEqual)(this.lastParams, currentParams);
+              paramProviderChanged = !(0, _lodashEs.isEqual)(this.lastParamProviderValues, currentParamProvider); // Smart merge based on what actually changed:
+              if (paramsChanged && !paramProviderChanged) {
+                // Only script/params changed → params should win
+                latest = (0, _lodashEs.merge)({}, currentParamProvider, currentDataBinding, currentParams);
+              } else if (paramProviderChanged && !paramsChanged) {
+                // Only UI/paramProvider changed → paramProvider should win
+                latest = (0, _lodashEs.merge)({}, currentParams, currentDataBinding, currentParamProvider);
+              } else if (paramsChanged && paramProviderChanged) {
+                // Both changed → params wins (script is more intentional than UI)
+                latest = (0, _lodashEs.merge)({}, currentParamProvider, currentDataBinding, currentParams);
+              } else {
+                // Neither changed (first call) → params wins by default
+                latest = (0, _lodashEs.merge)({}, currentParamProvider, currentDataBinding, currentParams);
+              }
+              last = this.lastInvokedParams || {};
+              if (!(!(0, _lodashEs.isEqual)(last, latest) && latest !== undefined && !(0, _lodashEs.isEmpty)(latest))) {
+                _context.next = 25;
+                break;
+              }
+              if (!((0, _lodashEs.isEmpty)(last) && Object.values(latest).every(function (value) {
+                return value == null;
+              }))) {
+                _context.next = 13;
+                break;
+              }
+              return _context.abrupt("return", this);
+            case 13:
+              // Update all tracking values
+              this.lastInvokedParams = (0, _util.deepCopy)({}, latest);
+              this.lastParams = (0, _util.deepCopy)({}, currentParams);
+              this.lastParamProviderValues = (0, _util.deepCopy)({}, currentParamProvider);
+              _context.prev = 16;
+              _context.next = 19;
+              return new Promise(function (resolve, reject) {
+                _this2.invoke(latest, function (data) {
+                  return resolve(data);
+                }, function (error) {
+                  return reject(error);
+                });
+              });
+            case 19:
+              _context.next = 23;
+              break;
+            case 21:
+              _context.prev = 21;
+              _context.t0 = _context["catch"](16);
+            case 23:
+              _context.next = 27;
+              break;
+            case 25:
+              // Even if not invoking, update tracking to detect future changes
+              this.lastParams = (0, _util.deepCopy)({}, currentParams);
+              this.lastParamProviderValues = (0, _util.deepCopy)({}, currentParamProvider);
+            case 27:
+              return _context.abrupt("return", this);
+            case 28:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[16, 21]]);
+      }));
+      function invokeOnParamChange(_x, _x2, _x3) {
+        return _invokeOnParamChange.apply(this, arguments);
+      }
+      return invokeOnParamChange;
+    }()
+  }, {
+    key: "doNext",
+    value: function () {
+      var _doNext = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _this3 = this;
+        var page;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              page = 0;
+              if ((0, _lodashEs.isString)(this.pagination.page)) {
+                page = parseInt(this.pagination.page) + 1 + "";
+              } else {
+                page = this.pagination.page + 1;
+              }
+              return _context2.abrupt("return", new Promise(function (resolve, reject) {
+                _this3.invoke({
+                  page: page
+                }, function (dataset) {
+                  return resolve(dataset);
+                }, reject);
+              }));
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function doNext() {
+        return _doNext.apply(this, arguments);
+      }
+      return doNext;
+    }()
+  }, {
+    key: "onDataUpdated",
+    value: function onDataUpdated() {
+      console.log("called in onDataUpdated");
+    }
+  }, {
+    key: "invoke",
+    value: function invoke(options, onSuccess, onError) {
+      // Build request params locally — never mutate this.params, this.dataBinding, or options.inputFields
+      var inputFields = (0, _lodashEs.merge)({}, this.config.paramProvider(), this.dataBinding, this.params);
+      if (options) {
+        var _options$inputFields;
+        var overrides = (_options$inputFields = options.inputFields) !== null && _options$inputFields !== void 0 ? _options$inputFields : options;
+        inputFields = (0, _lodashEs.merge)({}, inputFields, overrides);
+      } else {
+        options = {};
+      }
+      options.inputFields = inputFields;
+      this.lastInvokedParams = inputFields;
+
+      // Normalize orderBy option
+      if (!options.orderBy) {
+        var cfg = this.config;
+        var defaultOrder = (cfg === null || cfg === void 0 ? void 0 : cfg.orderBy) || (cfg === null || cfg === void 0 ? void 0 : cfg.orderby) || this.orderBy || this.orderby;
+        if (defaultOrder) {
+          var norm = String(defaultOrder);
+          options.orderBy = norm.includes(":") ? norm.replace(/:/g, " ") : norm;
+        }
+      }
+      // Get the latest service definition
+      this.serviceInfo = this.config.getServiceInfo();
+      if (!this.serviceInfo) {
+        console.error("Service Info is missing for (".concat(this.name, ") variable."));
+      }
+      return _superPropGet(ServiceVariable, "invoke", this, 3)([options, onSuccess, onError]);
+    }
+  }, {
+    key: "setInput",
+    value: function setInput(key, val, options) {
+      this.dataBinding = (0, _lodashEs.merge)({}, _setInput(this.dataBinding, key, val, options));
+      return this.dataBinding;
+    }
+  }]);
+}(_variables.ServiceVariable);
+var _setInput = exports._setInput = function _setInput(targetObj, key, val, options) {
+  targetObj = targetObj || {};
+  var keys,
+    lastKey,
+    paramObj = {};
+
+  // content type check
+  if ((0, _lodashEs.isObject)(options)) {
+    // @ts-ignore
+    switch (options.type) {
+      case "file":
+        //val = getBlob(val, options.contentType);
+        break;
+      case "number":
+        val = (0, _lodashEs.isNumber)(val) ? val : parseInt(val, 10);
+        break;
+    }
+  }
+  if ((0, _lodashEs.isObject)(key)) {
+    // check if the passed parameter is an object itself
+    paramObj = key;
+  } else if (key.indexOf(".") > -1) {
+    // check for '.' in key e.g. 'employee.department'
+    keys = key.split(".");
+    lastKey = keys.pop();
+    // Finding the object based on the key
+    targetObj = (0, _formatUtil.findValueOf)(targetObj, keys.join("."));
+    key = lastKey;
+    paramObj[key] = val;
+  } else {
+    paramObj[key] = val;
+  }
+  (0, _lodashEs.forEach)(paramObj, function (paramVal, paramKey) {
+    targetObj[paramKey] = paramVal;
+  });
+  return targetObj;
+};

package/wm-namespace.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Central WaveMaker npm namespace configuration.
+ *
+ * All source files import WM_NPM_SCOPE from here instead of hardcoding
+ * '@wavemaker'. Override via the WM_NPM_SCOPE environment variable to
+ * switch namespaces at build or runtime.
+ *
+ * Default: '@wavemaker-ai'
+ * Override: WM_NPM_SCOPE=@wavemaker node scripts/build.js post-build
+ */
+export const WM_NPM_SCOPE: string;

package/wm-namespace.js

@@ -0,0 +1,14 @@
+/**
+ * Central WaveMaker npm namespace configuration.
+ *
+ * All source files import WM_NPM_SCOPE from here instead of hardcoding
+ * '@wavemaker'. Override via the WM_NPM_SCOPE environment variable to
+ * switch namespaces at build or runtime.
+ *
+ * Default: '@wavemaker-ai'
+ * Override: WM_NPM_SCOPE=@wavemaker node scripts/build.js post-build
+ */
+var WM_NPM_SCOPE = process.env.WM_NPM_SCOPE || "@wavemaker-ai";
+module.exports = {
+  WM_NPM_SCOPE: WM_NPM_SCOPE
+};