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

package/core/constants/events.d.ts

@@ -0,0 +1,24 @@
+import EventEmitter from "events";
+export declare const EVENTEMITTER_METHODS: {
+    PREFAB_STATE_SYNC_ON: (name: string, callback: (data: any) => void) => EventEmitter<[never]>;
+    PREFAB_STATE_SYNC_OFF: (name: string, callback: (data: any) => void) => EventEmitter<[never]>;
+    PREFAB_STATE_SYNC_EMIT: (name: string, data: any) => boolean;
+    PARTIAL_STATE_SYNC_ON: (callback: (data: any) => void) => EventEmitter<[never]>;
+    PARTIAL_STATE_SYNC_OFF: (callback: (data: any) => void) => EventEmitter<[never]>;
+    PARTIAL_STATE_SYNC_EMIT: (data: any) => boolean;
+    LAYOUT_STATE_REFRESH_ON: (callback: (data: {
+        layoutName: string;
+        layout: Record<string, any>;
+        proxy: any;
+    }) => void) => EventEmitter<[never]>;
+    LAYOUT_STATE_REFRESH_OFF: (callback: (data: {
+        layoutName: string;
+        layout: Record<string, any>;
+        proxy: any;
+    }) => void) => EventEmitter<[never]>;
+    LAYOUT_STATE_REFRESH_EMIT: (data: {
+        layoutName: string;
+        layout: Record<string, any>;
+        proxy: any;
+    }) => boolean;
+};

package/core/constants/events.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EVENTEMITTER_METHODS = void 0;
+var _events = _interopRequireDefault(require("events"));
+var partialStateSyncEmitter = new _events["default"]();
+var prefabStateSyncEmitter = new _events["default"]();
+var layoutSyncEmitter = new _events["default"]();
+
+// Pages with many partials/prefabs legitimately register one listener each.
+// The default limit of 10 is too low for widget-heavy WaveMaker pages.
+partialStateSyncEmitter.setMaxListeners(50);
+prefabStateSyncEmitter.setMaxListeners(50);
+layoutSyncEmitter.setMaxListeners(50);
+
+// NOTE: Form-related events (CHILD_FORM_DATA_UPDATE, CHILD_FORM_FIELD_REGISTER) have been removed.
+// Form communication now uses context-based callbacks via ParentFormDataContext:
+// - onChildDataChange: For child forms to send data UP to root parent
+// - registerChildField: For prefab forms to register fields in parent's widget context
+
+var EVENTEMITTER = {
+  LAYOUT_STATE_REFRESH: "layout-state-refresh",
+  PARTIAL_STATE_SYNC: "partial-state-sync",
+  PREFAB_STATE_SYNC: "prefab-state-sync"
+};
+var EVENTEMITTER_METHODS = exports.EVENTEMITTER_METHODS = {
+  PREFAB_STATE_SYNC_ON: function PREFAB_STATE_SYNC_ON() {
+    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+    var callback = arguments.length > 1 ? arguments[1] : undefined;
+    return prefabStateSyncEmitter.on(EVENTEMITTER.PREFAB_STATE_SYNC + (name ? "_" + name : ""), callback);
+  },
+  PREFAB_STATE_SYNC_OFF: function PREFAB_STATE_SYNC_OFF() {
+    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+    var callback = arguments.length > 1 ? arguments[1] : undefined;
+    return prefabStateSyncEmitter.off(EVENTEMITTER.PREFAB_STATE_SYNC + (name ? "_" + name : ""), callback);
+  },
+  PREFAB_STATE_SYNC_EMIT: function PREFAB_STATE_SYNC_EMIT() {
+    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+    var data = arguments.length > 1 ? arguments[1] : undefined;
+    return prefabStateSyncEmitter.emit(EVENTEMITTER.PREFAB_STATE_SYNC + (name ? "_" + name : ""), data);
+  },
+  PARTIAL_STATE_SYNC_ON: function PARTIAL_STATE_SYNC_ON(callback) {
+    return partialStateSyncEmitter.on(EVENTEMITTER.PARTIAL_STATE_SYNC, callback);
+  },
+  PARTIAL_STATE_SYNC_OFF: function PARTIAL_STATE_SYNC_OFF(callback) {
+    return partialStateSyncEmitter.off(EVENTEMITTER.PARTIAL_STATE_SYNC, callback);
+  },
+  PARTIAL_STATE_SYNC_EMIT: function PARTIAL_STATE_SYNC_EMIT(data) {
+    return partialStateSyncEmitter.emit(EVENTEMITTER.PARTIAL_STATE_SYNC, data);
+  },
+  LAYOUT_STATE_REFRESH_ON: function LAYOUT_STATE_REFRESH_ON(callback) {
+    return layoutSyncEmitter.on(EVENTEMITTER.LAYOUT_STATE_REFRESH, callback);
+  },
+  LAYOUT_STATE_REFRESH_OFF: function LAYOUT_STATE_REFRESH_OFF(callback) {
+    return layoutSyncEmitter.off(EVENTEMITTER.LAYOUT_STATE_REFRESH, callback);
+  },
+  LAYOUT_STATE_REFRESH_EMIT: function LAYOUT_STATE_REFRESH_EMIT(data) {
+    return layoutSyncEmitter.emit(EVENTEMITTER.LAYOUT_STATE_REFRESH, data);
+  }
+};

package/core/constants/index.d.ts

@@ -0,0 +1,10 @@
+/** Production / default SPA URL segment (embedded apps, classic deploy). */
+export declare const ROUTING_BASEPATH_PRODUCTION = "react-pages";
+/** Studio / dynamic preview uses this segment in the browser URL (runtime-dynamic). */
+export declare const PREVIEW_ROUTING_BASEPATH = "react-preview";
+/**
+ * SPA routing segment for the current window (`react-pages` vs `react-preview`).
+ * Call when building navigation targets — not a one-time module-load constant.
+ */
+export declare function getActiveRoutingBasePath(): string;
+export declare const hyperLinkMofify: (link: string) => string;

package/core/constants/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROUTING_BASEPATH_PRODUCTION = exports.PREVIEW_ROUTING_BASEPATH = void 0;
+exports.getActiveRoutingBasePath = getActiveRoutingBasePath;
+exports.hyperLinkMofify = void 0;
+/** Production / default SPA URL segment (embedded apps, classic deploy). */
+var ROUTING_BASEPATH_PRODUCTION = exports.ROUTING_BASEPATH_PRODUCTION = "react-pages";
+
+/** Studio / dynamic preview uses this segment in the browser URL (runtime-dynamic). */
+var PREVIEW_ROUTING_BASEPATH = exports.PREVIEW_ROUTING_BASEPATH = "react-preview";
+
+/**
+ * SPA routing segment for the current window (`react-pages` vs `react-preview`).
+ * Call when building navigation targets — not a one-time module-load constant.
+ */
+function getActiveRoutingBasePath() {
+  if (typeof window === "undefined") {
+    return ROUTING_BASEPATH_PRODUCTION;
+  }
+  var pathname = window.location.pathname;
+  var preview = "/".concat(PREVIEW_ROUTING_BASEPATH);
+  var prod = "/".concat(ROUTING_BASEPATH_PRODUCTION);
+  if (pathname.includes("".concat(preview, "/")) || pathname.endsWith(preview)) {
+    return PREVIEW_ROUTING_BASEPATH;
+  }
+  if (pathname.includes("".concat(prod, "/")) || pathname.endsWith(prod)) {
+    return ROUTING_BASEPATH_PRODUCTION;
+  }
+  return ROUTING_BASEPATH_PRODUCTION;
+}
+var hyperLinkMofify = exports.hyperLinkMofify = function hyperLinkMofify(link) {
+  var hrefLink = "#";
+  if (link) {
+    var segment = getActiveRoutingBasePath();
+    if (/^#/.test(link)) {
+      var suffix = link.replace(/^#/, "");
+      hrefLink = /^\/.*/.test(suffix) ? "/".concat(segment).concat(suffix) : "/".concat(segment, "/").concat(suffix);
+    } else if (/^\//.test(link)) {
+      var normalized = link.replace(new RegExp("^/".concat(ROUTING_BASEPATH_PRODUCTION, "(?=/|$)")), "/".concat(segment)).replace(new RegExp("^/".concat(PREVIEW_ROUTING_BASEPATH, "(?=/|$)")), "/".concat(segment));
+      hrefLink = normalized.match(new RegExp("^/".concat(segment, "(/|$)"))) ? normalized : "/".concat(segment).concat(link);
+    } else {
+      hrefLink = link;
+    }
+  }
+  return hrefLink;
+};

package/core/dialog.service.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+interface DialogInstance {
+    open: () => void;
+    close: (event?: React.SyntheticEvent) => void;
+    isOpen: boolean;
+    component: React.ComponentType<any>;
+}
+interface DialogServiceInterface {
+    registerDialog(name: string, dialogInstance: DialogInstance): void;
+    unregisterDialog(name: string): void;
+    open(dialogName: string): void;
+    close(dialogName: string): void;
+    getDialog(dialogName: string): DialogInstance | null;
+    getAllDialogs(): Record<string, DialogInstance>;
+    isDialogOpen(dialogName: string): boolean;
+}
+declare class DialogService implements DialogServiceInterface {
+    private dialogs;
+    registerDialog(name: string, dialogInstance: DialogInstance): void;
+    unregisterDialog(name: string): void;
+    open(dialogName: string): void;
+    close(dialogName: string): void;
+    getDialog(dialogName: string): DialogInstance | null;
+    getAllDialogs(): Record<string, DialogInstance>;
+    isDialogOpen(dialogName: string): boolean;
+    getDialogNames(): string[];
+    clear(): void;
+}
+declare const dialogService: DialogService;
+export default dialogService;
+export type { DialogInstance, DialogServiceInterface };

package/core/dialog.service.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var DialogService = /*#__PURE__*/function () {
+  function DialogService() {
+    (0, _classCallCheck2["default"])(this, DialogService);
+    (0, _defineProperty2["default"])(this, "dialogs", new Map());
+  }
+  return (0, _createClass2["default"])(DialogService, [{
+    key: "registerDialog",
+    value: function registerDialog(name, dialogInstance) {
+      this.dialogs.set(name, dialogInstance);
+    }
+  }, {
+    key: "unregisterDialog",
+    value: function unregisterDialog(name) {
+      this.dialogs["delete"](name);
+    }
+  }, {
+    key: "open",
+    value: function open(dialogName) {
+      var dialog = this.dialogs.get(dialogName);
+      if (dialog) {
+        dialog.open();
+      } else {
+        console.error("Dialog \"".concat(dialogName, "\" not found. Available dialogs: ").concat(Array.from(this.dialogs.keys()).join(", ")));
+      }
+    }
+  }, {
+    key: "close",
+    value: function close(dialogName) {
+      var dialog = this.dialogs.get(dialogName);
+      if (dialog) {
+        dialog.close();
+      } else {
+        console.error("Dialog \"".concat(dialogName, "\" not found. Available dialogs: ").concat(Array.from(this.dialogs.keys()).join(", ")));
+      }
+    }
+  }, {
+    key: "getDialog",
+    value: function getDialog(dialogName) {
+      return this.dialogs.get(dialogName) || null;
+    }
+  }, {
+    key: "getAllDialogs",
+    value: function getAllDialogs() {
+      return Object.fromEntries(this.dialogs.entries());
+    }
+  }, {
+    key: "isDialogOpen",
+    value: function isDialogOpen(dialogName) {
+      var dialog = this.dialogs.get(dialogName);
+      return dialog ? dialog.isOpen : false;
+    }
+  }, {
+    key: "getDialogNames",
+    value: function getDialogNames() {
+      return Array.from(this.dialogs.keys());
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.dialogs.clear();
+    }
+  }]);
+}(); // Create a singleton instance
+var dialogService = new DialogService();
+var _default = exports["default"] = dialogService;

package/core/event-notifier.d.ts

@@ -0,0 +1,20 @@
+export default class EventNotifier {
+    static ROOT: EventNotifier;
+    name: string;
+    id: number;
+    private listeners;
+    private parent;
+    private children;
+    setParent(parent: EventNotifier): void;
+    notifyApp(event: string, ...data: any[]): void;
+    notify(event: string, args: any[], emitToParent?: boolean): void;
+    subscribe(event: string, fn: Function): () => void;
+    unsubscribe(event: string, fn: Function): void;
+    private removeFromParent;
+    destroy(): void;
+}
+export declare function eventObserver(): {
+    subscribe(callback: any): () => void;
+    next(value: any): void;
+    unsubscribe(callback: any): void;
+};

package/core/event-notifier.js

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.eventObserver = eventObserver;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _EventNotifier;
+var i = 1;
+var EventNotifier = exports["default"] = /*#__PURE__*/function () {
+  function EventNotifier() {
+    (0, _classCallCheck2["default"])(this, EventNotifier);
+    (0, _defineProperty2["default"])(this, "name", "");
+    (0, _defineProperty2["default"])(this, "id", i++);
+    (0, _defineProperty2["default"])(this, "listeners", {});
+    (0, _defineProperty2["default"])(this, "parent", EventNotifier.ROOT);
+    (0, _defineProperty2["default"])(this, "children", []);
+  }
+  return (0, _createClass2["default"])(EventNotifier, [{
+    key: "setParent",
+    value: function setParent(parent) {
+      if (parent !== this.parent) {
+        this.removeFromParent();
+        this.parent = parent;
+        this.parent.children.push(this);
+      }
+    }
+  }, {
+    key: "notifyApp",
+    value: function notifyApp(event) {
+      for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        data[_key - 1] = arguments[_key];
+      }
+      // Extract the last argument if it's a boolean for emitToParent
+      var args = data;
+
+      // Check if the last argument is a boolean (for backward compatibility)
+      if (data.length > 0 && typeof data[data.length - 1] === "boolean") {
+        args = data;
+      }
+      var propagate = true;
+      if (this.listeners[event]) {
+        propagate = !this.listeners[event].find(function (l) {
+          try {
+            return (l && l.apply(null, args)) === false;
+          } catch (e) {
+            console.error(e);
+          }
+          return true;
+        });
+      }
+    }
+  }, {
+    key: "notify",
+    value: function notify(event, args) {
+      var emitToParent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var propagate = true;
+      if (this.listeners[event]) {
+        propagate = !this.listeners[event].find(function (l) {
+          try {
+            return (l && l.apply(null, args)) === false;
+          } catch (e) {
+            console.error(e);
+          }
+          return true;
+        });
+      }
+      if (propagate) {
+        if (emitToParent) {
+          var _this$parent;
+          (_this$parent = this.parent) === null || _this$parent === void 0 || _this$parent.notify(event, args, true);
+        } else {
+          this.children.forEach(function (c) {
+            c.notify(event, args);
+          });
+        }
+      }
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(event, fn) {
+      var _this = this;
+      this.listeners[event] = this.listeners[event] || [];
+      this.listeners[event].push(fn);
+      return function () {
+        _this.unsubscribe(event, fn);
+      };
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(event, fn) {
+      if (!this.listeners[event]) return;
+      var index = this.listeners[event].findIndex(function (listener) {
+        return listener === fn;
+      });
+      if (index !== -1) {
+        this.listeners[event].splice(index, 1);
+        if (this.listeners[event].length === 0) {
+          delete this.listeners[event];
+        }
+      }
+    }
+  }, {
+    key: "removeFromParent",
+    value: function removeFromParent() {
+      if (this.parent) {
+        var _i = this.parent.children.indexOf(this) || -1;
+        if (_i >= 0) {
+          this.parent.children.splice(_i, 1);
+        }
+        this.parent = null;
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.removeFromParent();
+      this.listeners = {};
+    }
+  }]);
+}();
+_EventNotifier = EventNotifier;
+(0, _defineProperty2["default"])(EventNotifier, "ROOT", new _EventNotifier());
+function eventObserver() {
+  var observers = [];
+  return {
+    subscribe: function subscribe(callback) {
+      observers.push(callback);
+      return function () {
+        observers = observers.filter(function (obs) {
+          return obs !== callback;
+        });
+      };
+    },
+    next: function next(value) {
+      observers.forEach(function (callback) {
+        return callback(value);
+      });
+    },
+    unsubscribe: function unsubscribe(callback) {
+      observers = observers.filter(function (obs) {
+        return obs !== callback;
+      });
+    }
+  };
+}

package/core/formatter/array-formatters.d.ts

@@ -0,0 +1,4 @@
+import { Formatter } from "./types";
+export declare class FilterFormatter implements Formatter {
+    format(data: any[], field: string | Record<string, any>, value?: any): any[];
+}

package/core/formatter/array-formatters.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilterFormatter = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _isObject = _interopRequireDefault(require("lodash-es/isObject"));
+var _includes = _interopRequireDefault(require("lodash-es/includes"));
+var _filter = _interopRequireDefault(require("lodash-es/filter"));
+var FilterFormatter = exports.FilterFormatter = /*#__PURE__*/function () {
+  function FilterFormatter() {
+    (0, _classCallCheck2["default"])(this, FilterFormatter);
+  }
+  return (0, _createClass2["default"])(FilterFormatter, [{
+    key: "format",
+    value: function format(data, field, value) {
+      if (!data) {
+        return [];
+      }
+      // If object is passed as first parameter
+      if ((0, _isObject["default"])(field)) {
+        return (0, _filter["default"])(data, field);
+      }
+      // If key value pair is provided
+      return (0, _filter["default"])(data, function (item) {
+        return (0, _includes["default"])(item[field], value);
+      });
+    }
+  }]);
+}();

package/core/formatter/date-formatters.d.ts

@@ -0,0 +1,9 @@
+import { DateFormatter } from "@wavemaker-ai/variables/src/types/date-formatter";
+import { Formatter } from "./types";
+export declare class DateToStringFormatter implements DateFormatter {
+    format(input: Date | string | number | null | undefined, format?: string | null): string;
+    private tryReconstructDateFromDecimal;
+}
+export declare class TimeFromNowFormatter implements Formatter {
+    format(timestamp: Date | string | number | null | undefined): string;
+}