web-mojo 2.2.57 → 2.2.59

package/dist/chunks/WebApp-6qvqmOts.js

@@ -1,1386 +0,0 @@
-import { r as rest } from "./Rest-W-sPfGh9.js";
-class Router {
-  constructor(options = {}) {
-    this.defaultRoute = options.defaultRoute || "home";
-    this.routes = [];
-    this.currentRoute = null;
-    this.eventEmitter = options.eventEmitter || null;
-    this.boundHandlePopState = this.handlePopState.bind(this);
-  }
-  start() {
-    window.addEventListener("popstate", this.boundHandlePopState);
-    this.handleCurrentLocation();
-  }
-  stop() {
-    window.removeEventListener("popstate", this.boundHandlePopState);
-  }
-  addRoute(pattern, pageName) {
-    this.routes.push({
-      pattern: this.normalizePattern(pattern),
-      regex: this.patternToRegex(pattern),
-      pageName,
-      paramNames: this.extractParamNames(pattern)
-    });
-  }
-  async navigate(path, options = {}) {
-    const { replace = false, state = null, trigger = true } = options;
-    const { pageName, queryParams } = this.parseInput(path);
-    if (trigger) {
-      await this.handleRouteChange(pageName, queryParams);
-    }
-  }
-  // Browser navigation
-  back() {
-    window.history.back();
-  }
-  forward() {
-    window.history.forward();
-  }
-  // Get current route info
-  getCurrentRoute() {
-    return this.currentRoute;
-  }
-  getCurrentPath() {
-    const { pageName, queryParams } = this.parseCurrentUrl();
-    return this.buildPublicUrl(pageName, queryParams);
-  }
-  // Private methods
-  handlePopState(_event) {
-    if (this.allowPopState) {
-      this.handleCurrentLocation();
-    } else {
-      console.warn("PopStateEvent is not allowed");
-    }
-  }
-  async handleCurrentLocation() {
-    const { pageName, queryParams } = this.parseCurrentUrl();
-    await this.handleRouteChange(pageName, queryParams);
-  }
-  async handleRouteChange(pageName, queryParams) {
-    const routePath = "/" + pageName;
-    const route = this.matchRoute(routePath);
-    const publicUrl = this.buildPublicUrl(pageName, queryParams);
-    if (!route) {
-      console.log("No route matched for page:", pageName);
-      if (this.eventEmitter) {
-        this.eventEmitter.emit("route:notfound", { path: publicUrl });
-      }
-      return null;
-    }
-    this.currentRoute = route;
-    if (this.eventEmitter) {
-      this.eventEmitter.emit("route:changed", {
-        path: publicUrl,
-        pageName: route.pageName,
-        params: route.params,
-        query: queryParams,
-        route
-      });
-    }
-    return route;
-  }
-  matchRoute(path) {
-    for (const route of this.routes) {
-      const match = path.match(route.regex);
-      if (match) {
-        const params = {};
-        route.paramNames.forEach((name, index) => {
-          params[name] = match[index + 1];
-        });
-        return {
-          ...route,
-          params,
-          path
-        };
-      }
-    }
-    return null;
-  }
-  // Parse any input format and extract page name + query params
-  parseInput(input) {
-    let pageName = this.defaultRoute;
-    let queryParams = {};
-    if (!input) {
-      return { pageName, queryParams };
-    }
-    try {
-      if (input.includes("?")) {
-        const [pathPart, queryPart] = input.split("?", 2);
-        const urlParams = new URLSearchParams(queryPart);
-        if (urlParams.has("page")) {
-          pageName = urlParams.get("page") || this.defaultRoute;
-          for (const [key, value] of urlParams) {
-            if (key !== "page") {
-              queryParams[key] = value;
-            }
-          }
-        } else {
-          if (pathPart.startsWith("/")) {
-            pageName = pathPart.substring(1) || this.defaultRoute;
-          } else {
-            pageName = pathPart || this.defaultRoute;
-          }
-          for (const [key, value] of urlParams) {
-            queryParams[key] = value;
-          }
-        }
-      } else if (input.startsWith("/")) {
-        pageName = input.substring(1) || this.defaultRoute;
-      } else {
-        pageName = input;
-      }
-    } catch (error) {
-      console.warn("Failed to parse input:", input, error);
-      pageName = this.defaultRoute;
-      queryParams = {};
-    }
-    return { pageName, queryParams };
-  }
-  // Parse current browser URL
-  parseCurrentUrl() {
-    const urlParams = new URLSearchParams(window.location.search);
-    const pageName = urlParams.get("page") || this.defaultRoute;
-    const queryParams = {};
-    for (const [key, value] of urlParams) {
-      if (key !== "page") {
-        queryParams[key] = value;
-      }
-    }
-    return { pageName, queryParams };
-  }
-  // Build public URL format: ?page=admin&group=123
-  buildPublicUrl(pageName, queryParams = {}) {
-    const urlParams = new URLSearchParams();
-    urlParams.set("page", pageName);
-    Object.entries(queryParams).forEach(([key, value]) => {
-      if (value !== null && value !== void 0 && value !== "") {
-        urlParams.set(key, String(value));
-      }
-    });
-    return "?" + urlParams.toString();
-  }
-  // Update browser URL
-  updateBrowserUrl(pageName, queryParams, replace, state) {
-    const currentUrl = new URL(window.location.origin + window.location.pathname);
-    currentUrl.searchParams.set("page", pageName);
-    Object.entries(queryParams).forEach(([key, value]) => {
-      if (value !== null && value !== void 0 && value !== "") {
-        currentUrl.searchParams.set(key, String(value));
-      }
-    });
-    const url = currentUrl.toString();
-    if (replace) {
-      window.history.replaceState(state, "", url);
-    } else {
-      window.history.pushState(state, "", url);
-    }
-  }
-  // Route pattern utilities
-  patternToRegex(pattern) {
-    let regexPattern = pattern.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&").replace(/\/:([^/?]+)\?/g, "(?:/([^/]+))?").replace(/:([^/]+)/g, "([^/]+)");
-    return new RegExp(`^${regexPattern}$`);
-  }
-  extractParamNames(pattern) {
-    const matches = pattern.match(/:([^/?]+)\??/g) || [];
-    return matches.map((match) => match.replace(/[:?]/g, ""));
-  }
-  normalizePattern(pattern) {
-    return pattern.startsWith("/") ? pattern : `/${pattern}`;
-  }
-  /**
-   * Update URL parameters without triggering navigation
-   * @param {object} params - Parameters to update in URL
-   * @param {object} options - Options like { replace: true }
-   */
-  updateUrl(params = {}, options = {}) {
-    const { replace = false } = options;
-    const { pageName } = this.parseCurrentUrl();
-    this.updateBrowserUrl(pageName, params, replace);
-  }
-  /**
-   * Build URL for given page and query parameters
-   */
-  buildUrl(page, query = {}) {
-    return this.buildPublicUrl(page, query);
-  }
-  /**
-   * Check if two routes match (ignoring query parameters)
-   * @param {string} route1 - First route in any format ("/admin", "?page=admin", "admin")
-   * @param {string} route2 - Second route in any format
-   * @returns {boolean} - True if routes point to the same page
-   */
-  doRoutesMatch(route1, route2) {
-    if (!route1 || !route2) return false;
-    const { pageName: pageName1 } = this.parseInput(route1);
-    const { pageName: pageName2 } = this.parseInput(route2);
-    return pageName1 === pageName2;
-  }
-}
-class EventBus {
-  constructor() {
-    this.listeners = {};
-    this.onceListeners = {};
-    this.maxListeners = 100;
-    this.debugMode = false;
-    this.eventStats = {};
-  }
-  /**
-   * Add event listener
-   * @param {string|Array<string>} event - Event name or array of event names
-   * @param {function} callback - Event callback
-   * @returns {EventBus} This instance for chaining
-   */
-  on(event, callback) {
-    if (typeof callback !== "function") {
-      throw new Error("Callback must be a function");
-    }
-    if (Array.isArray(event)) {
-      event.forEach((eventName) => this.on(eventName, callback));
-      return this;
-    }
-    if (!this.listeners[event]) {
-      this.listeners[event] = [];
-    }
-    if (this.listeners[event].length >= this.maxListeners) {
-      console.warn(`Max listeners (${this.maxListeners}) exceeded for event: ${event}`);
-    }
-    this.listeners[event].push(callback);
-    return this;
-  }
-  /**
-   * Add one-time event listener
-   * @param {string|Array<string>} event - Event name or array of event names
-   * @param {function} callback - Event callback
-   * @returns {EventBus} This instance for chaining
-   */
-  once(event, callback) {
-    if (typeof callback !== "function") {
-      throw new Error("Callback must be a function");
-    }
-    if (Array.isArray(event)) {
-      event.forEach((eventName) => this.once(eventName, callback));
-      return this;
-    }
-    if (!this.onceListeners[event]) {
-      this.onceListeners[event] = [];
-    }
-    this.onceListeners[event].push(callback);
-    return this;
-  }
-  /**
-   * Remove event listener
-   * @param {string|Array<string>} event - Event name or array of event names
-   * @param {function} callback - Event callback to remove
-   * @returns {EventBus} This instance for chaining
-   */
-  off(event, callback) {
-    if (Array.isArray(event)) {
-      event.forEach((eventName) => this.off(eventName, callback));
-      return this;
-    }
-    if (!callback) {
-      delete this.listeners[event];
-      delete this.onceListeners[event];
-      return this;
-    }
-    if (this.listeners[event]) {
-      const index = this.listeners[event].indexOf(callback);
-      if (index !== -1) {
-        this.listeners[event].splice(index, 1);
-        if (this.listeners[event].length === 0) {
-          delete this.listeners[event];
-        }
-      }
-    }
-    if (this.onceListeners[event]) {
-      const index = this.onceListeners[event].indexOf(callback);
-      if (index !== -1) {
-        this.onceListeners[event].splice(index, 1);
-        if (this.onceListeners[event].length === 0) {
-          delete this.onceListeners[event];
-        }
-      }
-    }
-    return this;
-  }
-  /**
-   * Emit event to all listeners
-   * @param {string} event - Event name
-   * @param {*} data - Event data
-   * @returns {EventBus} This instance for chaining
-   */
-  emit(event, data) {
-    this.updateEventStats(event);
-    if (this.debugMode) {
-      console.log(`[EventBus] Emitting: ${event}`, data);
-    }
-    const listeners = [];
-    if (this.listeners[event]) {
-      listeners.push(...this.listeners[event]);
-    }
-    if (this.listeners["*"]) {
-      listeners.push(...this.listeners["*"]);
-    }
-    if (this.onceListeners[event]) {
-      listeners.push(...this.onceListeners[event]);
-      delete this.onceListeners[event];
-    }
-    if (this.onceListeners["*"]) {
-      listeners.push(...this.onceListeners["*"]);
-      delete this.onceListeners["*"];
-    }
-    if (this.debugMode && listeners.length > 0) {
-      console.log(`[EventBus] ${listeners.length} listener(s) for '${event}'`);
-    }
-    listeners.forEach((callback) => {
-      try {
-        if (callback(data, event)) {
-          if (event.stopPropagation) {
-            event.stopPropagation();
-          }
-          if (event.preventDefault) {
-            event.preventDefault();
-          }
-        }
-      } catch (error) {
-        console.error(`Error in event listener for '${event}':`, error);
-        this.emitError(error, event, callback);
-      }
-    });
-    return this;
-  }
-  /**
-   * Emit event asynchronously
-   * @param {string} event - Event name
-   * @param {*} data - Event data
-   * @returns {Promise<EventBus>} Promise that resolves with this instance
-   */
-  async emitAsync(event, data) {
-    const listeners = [];
-    if (this.listeners[event]) {
-      listeners.push(...this.listeners[event]);
-    }
-    if (this.listeners["*"]) {
-      listeners.push(...this.listeners["*"]);
-    }
-    if (this.onceListeners[event]) {
-      listeners.push(...this.onceListeners[event]);
-      delete this.onceListeners[event];
-    }
-    if (this.onceListeners["*"]) {
-      listeners.push(...this.onceListeners["*"]);
-      delete this.onceListeners["*"];
-    }
-    const promises = listeners.map((callback) => {
-      return new Promise((resolve) => {
-        try {
-          const result = callback(data, event);
-          resolve(result);
-        } catch (error) {
-          console.error(`Error in async event listener for '${event}':`, error);
-          this.emitError(error, event, callback);
-          resolve();
-        }
-      });
-    });
-    await Promise.all(promises);
-    return this;
-  }
-  /**
-   * Remove all listeners for all events
-   * @returns {EventBus} This instance for chaining
-   */
-  removeAllListeners() {
-    this.listeners = {};
-    this.onceListeners = {};
-    return this;
-  }
-  /**
-   * Get listener count for an event
-   * @param {string} event - Event name
-   * @returns {number} Number of listeners
-   */
-  listenerCount(event) {
-    const regularCount = this.listeners[event] ? this.listeners[event].length : 0;
-    const onceCount = this.onceListeners[event] ? this.onceListeners[event].length : 0;
-    return regularCount + onceCount;
-  }
-  /**
-   * Get all event names that have listeners
-   * @returns {Array<string>} Array of event names
-   */
-  eventNames() {
-    const regularEvents = Object.keys(this.listeners);
-    const onceEvents = Object.keys(this.onceListeners);
-    return [.../* @__PURE__ */ new Set([...regularEvents, ...onceEvents])];
-  }
-  /**
-   * Set maximum number of listeners per event
-   * @param {number} max - Maximum listeners
-   * @returns {EventBus} This instance for chaining
-   */
-  setMaxListeners(max) {
-    if (typeof max !== "number" || max < 0) {
-      throw new Error("Max listeners must be a non-negative number");
-    }
-    this.maxListeners = max;
-    return this;
-  }
-  /**
-   * Create a namespaced event bus
-   * @param {string} namespace - Namespace prefix
-   * @returns {object} Namespaced event bus methods
-   */
-  namespace(namespace) {
-    const prefixEvent = (event) => `${namespace}:${event}`;
-    return {
-      on: (event, callback) => this.on(prefixEvent(event), callback),
-      once: (event, callback) => this.once(prefixEvent(event), callback),
-      off: (event, callback) => this.off(prefixEvent(event), callback),
-      emit: (event, data) => this.emit(prefixEvent(event), data),
-      emitAsync: (event, data) => this.emitAsync(prefixEvent(event), data)
-    };
-  }
-  /**
-   * Add middleware to intercept events
-   * @param {function} middleware - Middleware function
-   * @returns {EventBus} This instance for chaining
-   */
-  use(middleware) {
-    if (typeof middleware !== "function") {
-      throw new Error("Middleware must be a function");
-    }
-    const originalEmit = this.emit;
-    this.emit = (event, data) => {
-      try {
-        const result = middleware(event, data);
-        if (result === false) {
-          return this;
-        }
-        const finalData = result !== void 0 ? result : data;
-        return originalEmit.call(this, event, finalData);
-      } catch (error) {
-        console.error("Error in event middleware:", error);
-        return originalEmit.call(this, event, data);
-      }
-    };
-    return this;
-  }
-  /**
-   * Emit error event for listener errors
-   * @private
-   * @param {Error} error - The error that occurred
-   * @param {string} originalEvent - The event that caused the error
-   * @param {function} callback - The callback that threw the error
-   */
-  emitError(error, originalEvent, callback) {
-    if (originalEvent === "error") {
-      return;
-    }
-    setTimeout(() => {
-      this.emit("error", {
-        error,
-        originalEvent,
-        callback: callback.toString()
-      });
-    }, 0);
-  }
-  /**
-   * Create a promise that resolves when an event is emitted
-   * @param {string} event - Event name
-   * @param {number} timeout - Optional timeout in milliseconds
-   * @returns {Promise} Promise that resolves with event data
-   */
-  waitFor(event, timeout = null) {
-    return new Promise((resolve, reject) => {
-      let timeoutId = null;
-      const cleanup = () => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-      };
-      const listener = (data) => {
-        cleanup();
-        resolve(data);
-      };
-      this.once(event, listener);
-      if (timeout) {
-        timeoutId = setTimeout(() => {
-          this.off(event, listener);
-          reject(new Error(`Timeout waiting for event: ${event}`));
-        }, timeout);
-      }
-    });
-  }
-  /**
-   * Enable/disable debug mode for detailed event logging
-   * @param {boolean} enable - Whether to enable debug mode
-   * @returns {EventBus} This instance for chaining
-   */
-  debug(enable = true) {
-    this.debugMode = enable;
-    if (enable) {
-      console.log("[EventBus] Debug mode enabled");
-    } else {
-      console.log("[EventBus] Debug mode disabled");
-    }
-    return this;
-  }
-  /**
-   * Get statistics about the event bus
-   * @returns {object} Statistics object
-   */
-  getStats() {
-    const eventNames = this.eventNames();
-    const stats = {
-      totalEvents: eventNames.length,
-      totalListeners: 0,
-      events: {},
-      emissions: { ...this.eventStats }
-    };
-    eventNames.forEach((event) => {
-      const count = this.listenerCount(event);
-      stats.events[event] = count;
-      stats.totalListeners += count;
-    });
-    return stats;
-  }
-  /**
-   * Update event emission statistics
-   * @private
-   * @param {string} event - Event name
-   */
-  updateEventStats(event) {
-    if (!this.eventStats[event]) {
-      this.eventStats[event] = {
-        count: 0,
-        firstEmission: Date.now(),
-        lastEmission: null
-      };
-    }
-    this.eventStats[event].count++;
-    this.eventStats[event].lastEmission = Date.now();
-  }
-  /**
-   * Get detailed statistics for a specific event
-   * @param {string} event - Event name
-   * @returns {Object} Event statistics
-   */
-  getEventStats(event) {
-    const stats = this.eventStats[event];
-    if (!stats) {
-      return null;
-    }
-    return {
-      ...stats,
-      listenerCount: this.listenerCount(event),
-      avgEmissionsPerMinute: this.calculateEmissionRate(stats)
-    };
-  }
-  /**
-   * Calculate emission rate for an event
-   * @private
-   * @param {Object} stats - Event statistics
-   * @returns {number} Emissions per minute
-   */
-  calculateEmissionRate(stats) {
-    if (!stats.firstEmission || !stats.lastEmission) {
-      return 0;
-    }
-    const durationMs = stats.lastEmission - stats.firstEmission;
-    if (durationMs === 0) {
-      return 0;
-    }
-    const durationMinutes = durationMs / (1e3 * 60);
-    return Math.round(stats.count / durationMinutes * 100) / 100;
-  }
-  /**
-   * Reset event statistics
-   * @returns {EventBus} This instance for chaining
-   */
-  resetStats() {
-    this.eventStats = {};
-    return this;
-  }
-  /**
-   * Get a summary of the most active events
-   * @param {number} limit - Number of events to return (default: 10)
-   * @returns {Array} Array of event statistics sorted by emission count
-   */
-  getTopEvents(limit = 10) {
-    return Object.entries(this.eventStats).map(([event, stats]) => ({
-      event,
-      count: stats.count,
-      rate: this.calculateEmissionRate(stats),
-      listeners: this.listenerCount(event)
-    })).sort((a, b) => b.count - a.count).slice(0, limit);
-  }
-  /**
-   * Log comprehensive debug information
-   * @returns {EventBus} This instance for chaining
-   */
-  debugInfo() {
-    console.group("[EventBus] Debug Information");
-    console.log("Debug Mode:", this.debugMode);
-    console.log("Max Listeners:", this.maxListeners);
-    const stats = this.getStats();
-    console.log("Total Events:", stats.totalEvents);
-    console.log("Total Listeners:", stats.totalListeners);
-    if (Object.keys(this.eventStats).length > 0) {
-      console.log("Top Events:", this.getTopEvents(5));
-    }
-    console.groupEnd();
-    return this;
-  }
-}
-class WebApp {
-  constructor(config = {}) {
-    this.config = config;
-    this.initPluginRegistry();
-    this.name = config.name || "MOJO App";
-    this.version = config.version || "1.0.0";
-    this.debug = config.debug || false;
-    this.container = config.container || "#app";
-    this.layoutType = config.layout || "portal";
-    this.layoutConfig = config.layoutConfig || {};
-    if (config.sidebar) {
-      this.layoutConfig.sidebarConfig = config.sidebar;
-    }
-    if (config.topbar) {
-      this.layoutConfig.topbarConfig = config.topbar;
-    }
-    this.layout = null;
-    this.layoutConfig.containerId = this.container || this.containerId || "#app";
-    this.pageContainer = config.pageContainer || "#page-container";
-    this.basePath = config.basePath || "";
-    this.routerMode = config.routerMode || config.router?.mode || "param";
-    this.basePath = config.basePath || config.router?.base || "";
-    this.defaultRoute = config.defaultRoute || "home";
-    this.session = config.session || {};
-    this.router = null;
-    this.navigation = config.navigation || {};
-    this.state = {
-      currentPage: null,
-      previousPage: null,
-      loading: false
-    };
-    this.events = new EventBus();
-    this.rest = rest;
-    if (config.api) {
-      this.rest.configure(config.api);
-    }
-    this.router = new Router({
-      mode: this.routerMode === "param" ? "params" : this.routerMode,
-      basePath: this.basePath,
-      defaultRoute: this.defaultRoute,
-      eventEmitter: this.events
-    });
-    this.events.on("route:changed", async (routeInfo) => {
-      const { pageName, params, query } = routeInfo;
-      await this.showPage(pageName, query, params, { fromRouter: true });
-    });
-    if (typeof window !== "undefined") {
-      window.MOJO = window.MOJO || {};
-      window.MOJO.router = this.router;
-    }
-    this.setupFocusTracking();
-    this.pageCache = /* @__PURE__ */ new Map();
-    this.pageClasses = /* @__PURE__ */ new Map();
-    this.componentClasses = /* @__PURE__ */ new Map();
-    this.modelClasses = /* @__PURE__ */ new Map();
-    this.currentPage = null;
-    this.isStarted = false;
-    if (window.matchUUID) {
-      window[window.matchUUID] = this;
-    } else if (window.MOJO) {
-      window.MOJO.app = this;
-    } else {
-      window.__app__ = this;
-    }
-  }
-  /**
-   * Start the application
-   */
-  async start() {
-    if (this.isStarted) {
-      console.warn("WebApp already started");
-      return;
-    }
-    try {
-      this.setupPageContainer();
-      this.validateDefaultRoute();
-      await this.setupRouter();
-      this.isStarted = true;
-      this.router.allowPopState = false;
-      this.events.emit("app:ready", { app: this });
-    } catch (error) {
-      console.error(`Failed to start ${this.name}:`, error);
-      this.showError("Failed to start application");
-      throw error;
-    }
-  }
-  /**
-   * Setup router with configuration
-   */
-  async setupRouter() {
-    if (!this.router) {
-      console.error("Router not initialized");
-      return;
-    }
-    this.events.on("route:notfound", async (info) => {
-      console.warn(`Route not found: ${info.path}`);
-      this._show404(info.path);
-    });
-    this.router.start();
-    console.log(`Router started in ${this.routerMode} mode`);
-  }
-  /**
-   * Setup layout based on configuration
-   */
-  setupPageContainer() {
-    const container = typeof this.container === "string" ? document.querySelector(this.container) : this.container;
-    if (container && !container.querySelector("#page-container")) {
-      container.innerHTML = '<div id="page-container"></div>';
-    }
-    this.pageContainer = "#page-container";
-  }
-  /**
-   * Register a page with the app
-   */
-  registerPage(pageName, PageClass, options = {}) {
-    if (typeof pageName !== "string" || !pageName) {
-      console.error("registerPage: pageName must be a non-empty string");
-      return this;
-    }
-    if (typeof PageClass !== "function") {
-      console.error("registerPage: PageClass must be a constructor function");
-      return this;
-    }
-    if (!options.containerId) options.containerId = this.pageContainer;
-    this.pageClasses.set(pageName, {
-      PageClass,
-      constructorOptions: options
-    });
-    if (this.router) {
-      let route = options.route || `/${pageName}`;
-      if (!route.startsWith("/")) {
-        route = `/${route}`;
-      }
-      options.route = route;
-      this.router.addRoute(route, pageName);
-    }
-    return this;
-  }
-  /**
-   * Get page instance (cached)
-   */
-  getPage(pageName) {
-    return this.pageCache.get(pageName);
-  }
-  getPagePermissions(pageName) {
-    if (this.pageCache.has(pageName)) {
-      return this.pageCache.get(pageName).permissions;
-    }
-    const pageInfo = this.pageClasses.get(pageName);
-    if (!pageInfo) return null;
-    const { PageClass, constructorOptions } = pageInfo;
-    if (!constructorOptions) return null;
-    return constructorOptions.permissions;
-  }
-  /**
-   * Get or create page instance (with caching)
-   */
-  getOrCreatePage(pageName) {
-    if (this.pageCache.has(pageName)) {
-      return this.pageCache.get(pageName);
-    }
-    const pageInfo = this.pageClasses.get(pageName);
-    if (!pageInfo) {
-      console.error(`Page not registered: ${pageName}`);
-      return null;
-    }
-    const { PageClass, constructorOptions } = pageInfo;
-    try {
-      const pageOptions = {
-        pageName,
-        ...constructorOptions,
-        app: this
-      };
-      const page = new PageClass(pageOptions);
-      if (constructorOptions.route) {
-        page.route = constructorOptions.route;
-      }
-      this.pageCache.set(pageName, page);
-      console.log(`Created page: ${pageName} with route: ${page.route}`);
-      return page;
-    } catch (error) {
-      console.error(`Failed to create page ${pageName}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Show a page
-   */
-  /**
-   * SIMPLIFIED UNIFIED PAGE SHOWING METHOD
-   * @param {string|object} page - Page name or page instance
-   * @param {object} query - URL query parameters (URL-safe)
-   * @param {object} params - Any data to pass to page (can include objects)
-   * @param {object} options - Options { fromRouter, replace, force }
-   */
-  async showPage(page, query = {}, params = {}, options = {}) {
-    const { fromRouter = false, replace = false, force = false } = options;
-    try {
-      let pageInstance, pageName;
-      if (typeof page === "string") {
-        pageName = page;
-        pageInstance = this.getOrCreatePage(page);
-      } else if (page && typeof page === "object") {
-        pageInstance = page;
-        pageName = page.pageName;
-      }
-      const oldPage = this.currentPage;
-      if (!pageInstance) {
-        this._show404(pageName, params, query, fromRouter);
-        return;
-      }
-      this.events.emit("page:showing", {
-        page: pageInstance,
-        pageName: pageInstance.pageName,
-        params,
-        query,
-        fromRouter
-      });
-      if (!pageInstance.canEnter()) {
-        this._showDeniedPage(pageInstance, params, query, fromRouter);
-        return;
-      }
-      if (oldPage && oldPage !== pageInstance) {
-        await this._exitOldPage(oldPage);
-      }
-      await pageInstance.onParams(params, query);
-      if (oldPage !== pageInstance) {
-        await pageInstance.onEnter();
-      }
-      pageInstance.syncUrl();
-      this.events.emit("page:show", {
-        page: pageInstance,
-        pageName: pageInstance.pageName,
-        params,
-        query,
-        fromRouter
-      });
-      await pageInstance.render();
-      this.currentPage = pageInstance;
-      console.log(`✅ Showing page: ${pageInstance.pageName}`, { query, params });
-    } catch (error) {
-      console.error("Error in showPage:", error);
-      this.showError(`Failed to load page: ${error.message}`);
-      if (page !== "error") {
-        await this.showPage("error", {}, { error, originalPage: page }, { fromRouter });
-      }
-    }
-  }
-  async _show404(pageName, params, query, fromRouter) {
-    const notFoundPage = this.getOrCreatePage("404");
-    if (!notFoundPage) return;
-    if (notFoundPage.setInfo) {
-      notFoundPage.setInfo(pageName);
-    }
-    await this._exitOldPage(this.currentPage);
-    await notFoundPage.render();
-    this.currentPage = notFoundPage;
-    this.events.emit("page:404", {
-      page: null,
-      pageName,
-      params,
-      query,
-      fromRouter
-    });
-  }
-  async _showDeniedPage(pageInstance, params, query, fromRouter) {
-    const deniedPage = this.getOrCreatePage("denied");
-    if (deniedPage.setDeniedPage) {
-      deniedPage.setDeniedPage(pageInstance);
-    }
-    await this._exitOldPage(this.currentPage);
-    await deniedPage.render();
-    this.currentPage = deniedPage;
-    this.events.emit("page:denied", {
-      page: pageInstance,
-      pageName: pageInstance.pageName,
-      params,
-      query,
-      fromRouter
-    });
-  }
-  async _exitOldPage(oldPage) {
-    if (!oldPage) return;
-    try {
-      await oldPage.onExit();
-      await oldPage.unmount();
-      this.events.emit("page:hide", { page: oldPage });
-    } catch (error) {
-      console.error(`Error exiting page ${oldPage.pageName}:`, error);
-    }
-  }
-  /**
-   * SIMPLIFIED NAVIGATION - delegates to router
-   * @param {string} route - Route like "/users" or "/users/123"
-   * @param {object} query - Query string params { filter: 'active' }
-   * @param {object} options - Navigation options { replace, force }
-   */
-  async navigate(route, query = {}, options = {}) {
-    if (!this.router) {
-      console.error("Router not initialized");
-      return;
-    }
-    let fullPath = route;
-    if (Object.keys(query).length > 0) {
-      const queryString = new URLSearchParams(query).toString();
-      fullPath += (route.includes("?") ? "&" : "?") + queryString;
-    }
-    return await this.router.navigate(fullPath, options);
-  }
-  /**
-   * Navigate to the default route
-   */
-  async navigateToDefault(options = {}) {
-    return await this.showPage(this.defaultRoute, {}, {}, options);
-  }
-  /**
-   * Navigate back
-   */
-  back() {
-    if (this.router) {
-      this.router.back();
-    } else {
-      console.warn("Router not initialized");
-    }
-  }
-  /**
-   * Navigate forward
-   */
-  forward() {
-    if (this.router) {
-      this.router.forward();
-    } else {
-      console.warn("Router not initialized");
-    }
-  }
-  /**
-   * Get current page
-   */
-  getCurrentPage() {
-    return this.currentPage;
-  }
-  /**
-   * Get page container element
-   */
-  getPageContainer() {
-    if (this.layout && this.layout.getPageContainer) {
-      return this.layout.getPageContainer();
-    }
-    const container = typeof this.pageContainer === "string" ? document.querySelector(this.pageContainer) : this.pageContainer;
-    return container;
-  }
-  /**
-   * Show error notification
-   */
-  async showError(message) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      await Dialog.alert(message, "Error", { size: "md", class: "text-danger" });
-    } catch (e) {
-      this.events.emit("notification", { message, type: "error" });
-      if (typeof window !== "undefined" && window?.console) {
-        console.error("[WebApp] showError fallback:", e);
-      }
-      if (typeof window !== "undefined") {
-        alert(`Error: ${message}`);
-      }
-    }
-  }
-  /**
-   * Show success notification
-   */
-  async showSuccess(message) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      await Dialog.alert(message, "Success", { size: "md", class: "text-success" });
-    } catch (e) {
-      this.events.emit("notification", { message, type: "success" });
-      if (typeof window !== "undefined" && window?.console) {
-        console.warn("[WebApp] showSuccess fallback:", e);
-      }
-      if (typeof window !== "undefined") {
-        alert(`Success: ${message}`);
-      }
-    }
-  }
-  /**
-   * Show info notification
-   */
-  async showInfo(message) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      await Dialog.alert(message, "Information", { size: "md", class: "text-info" });
-    } catch (e) {
-      this.events.emit("notification", { message, type: "info" });
-      if (typeof window !== "undefined" && window?.console) {
-        console.info("[WebApp] showInfo fallback:", e);
-      }
-      if (typeof window !== "undefined") {
-        alert(`Info: ${message}`);
-      }
-    }
-  }
-  /**
-   * Show warning notification
-   */
-  async showWarning(message) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      await Dialog.alert(message, "Warning", { size: "md", class: "text-warning" });
-    } catch (e) {
-      this.events.emit("notification", { message, type: "warning" });
-      if (typeof window !== "undefined" && window?.console) {
-        console.warn("[WebApp] showWarning fallback:", e);
-      }
-      if (typeof window !== "undefined") {
-        alert(`Warning: ${message}`);
-      }
-    }
-  }
-  /**
-   * Show generic notification
-   */
-  showNotification(message, type = "info") {
-    this.events.emit("notification", { message, type });
-  }
-  /**
-   * Show loading indicator
-   */
-  async showLoading(opts = {}) {
-    if (typeof opts === "string") {
-      opts = { message: opts };
-    }
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      Dialog.showBusy(opts);
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.warn("[WebApp] showLoading fallback:", e, opts);
-      }
-      this.events.emit("notification", { message: opts.message || "Loading...", type: "info" });
-    }
-  }
-  /**
-   * Hide loading indicator
-   */
-  async hideLoading() {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      Dialog.hideBusy();
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.warn("[WebApp] hideLoading fallback:", e);
-      }
-    }
-  }
-  async showModelView(model, options = {}) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      return await Dialog.showModelView(model, options);
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.error("[WebApp] showModelForm failed:", e);
-      }
-      throw e;
-    }
-  }
-  async showModelForm(options = {}) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      return await Dialog.showModelForm(options);
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.error("[WebApp] showModelForm failed:", e);
-      }
-      throw e;
-    }
-  }
-  async showForm(options = {}) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      return await Dialog.showForm(options);
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.error("[WebApp] showForm failed:", e);
-      }
-      throw e;
-    }
-  }
-  async showDialog(options = {}) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      return await Dialog.showDialog(options);
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.error("[WebApp] showDialog failed:", e);
-      }
-      throw e;
-    }
-  }
-  async showAlert(options = {}) {
-    try {
-      const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-      return await Dialog.showDialog(options);
-    } catch (e) {
-      if (typeof window !== "undefined" && window?.console) {
-        console.error("[WebApp] showDialog failed:", e);
-      }
-      throw e;
-    }
-  }
-  async confirm(message, title = "Confirm", options = {}) {
-    const Dialog = (await import("./Dialog-DOGDalUq.js")).default;
-    return await Dialog.confirm(message, title, options);
-  }
-  /**
-   * Setup browser focus/blur tracking
-   */
-  setupFocusTracking() {
-    if (typeof window === "undefined") return;
-    this.isFocused = !document.hidden;
-    const handleVisibilityChange = () => {
-      const wasFocused = this.isFocused;
-      this.isFocused = !document.hidden;
-      if (wasFocused !== this.isFocused) {
-        if (this.isFocused) {
-          this.events.emit("browser:focus");
-        } else {
-          this.events.emit("browser:blur");
-        }
-      }
-    };
-    const handleFocus = () => {
-      if (!this.isFocused) {
-        this.isFocused = true;
-        this.events.emit("browser:focus");
-      }
-    };
-    const handleBlur = () => {
-      if (this.isFocused) {
-        this.isFocused = false;
-        this.events.emit("browser:blur");
-      }
-    };
-    document.addEventListener("visibilitychange", handleVisibilityChange);
-    window.addEventListener("focus", handleFocus);
-    window.addEventListener("blur", handleBlur);
-    this._focusHandlers = {
-      visibilitychange: handleVisibilityChange,
-      focus: handleFocus,
-      blur: handleBlur
-    };
-  }
-  /**
-   * Setup global error handling
-   */
-  setupErrorHandling() {
-    window.addEventListener("error", (event) => {
-      console.error("Global error:", event.error);
-      if (this.debug) {
-        this.showError(`Error: ${event.error?.message || "Unknown error"}`);
-      }
-    });
-    window.addEventListener("unhandledrejection", (event) => {
-      console.error("Unhandled promise rejection:", event.reason);
-      if (this.debug) {
-        this.showError(`Promise rejected: ${event.reason?.message || "Unknown error"}`);
-      }
-    });
-  }
-  /**
-   * Escape HTML to prevent XSS
-   */
-  escapeHtml(unsafe) {
-    return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-  }
-  /**
-   * Get application state
-   */
-  getState(key) {
-    return key ? this.state[key] : this.state;
-  }
-  /**
-   * Set application state
-   */
-  setState(updates) {
-    const oldState = { ...this.state };
-    Object.assign(this.state, updates);
-    this.events.emit("state:changed", {
-      oldState,
-      newState: this.state,
-      updates
-    });
-  }
-  /**
-   * Register component class
-   */
-  registerComponent(name, ComponentClass) {
-    this.componentClasses.set(name, ComponentClass);
-  }
-  /**
-   * Get component class
-   */
-  getComponent(name) {
-    return this.componentClasses.get(name);
-  }
-  /**
-   * Register model class
-   */
-  registerModel(name, ModelClass) {
-    this.modelClasses.set(name, ModelClass);
-  }
-  /**
-   * Get model class
-   */
-  getModel(name) {
-    return this.modelClasses.get(name);
-  }
-  /**
-   * Setup REST configuration
-   */
-  setupRest() {
-    this.rest = rest;
-    rest.configure(this.api);
-  }
-  /**
-   * Destroy the application
-   */
-  async destroy() {
-    console.log("Destroying WebApp...");
-    if (this.router) {
-      this.router.stop();
-    }
-    if (this._focusHandlers && typeof window !== "undefined") {
-      document.removeEventListener("visibilitychange", this._focusHandlers.visibilitychange);
-      window.removeEventListener("focus", this._focusHandlers.focus);
-      window.removeEventListener("blur", this._focusHandlers.blur);
-    }
-    const pages = Array.from(this.pageCache.values());
-    await Promise.allSettled(
-      pages.map(async (page) => {
-        try {
-          if (page.destroy) {
-            await page.destroy();
-          }
-        } catch (error) {
-          console.error("Error destroying page:", error);
-        }
-      })
-    );
-    if (this.layout && this.layout.destroy) {
-      try {
-        await this.layout.destroy();
-      } catch (error) {
-        console.error("Error destroying layout:", error);
-      }
-    }
-    this.pageCache.clear();
-    this.pageClasses.clear();
-    this.componentClasses.clear();
-    this.modelClasses.clear();
-    if (typeof window !== "undefined" && window.MOJO) {
-      delete window.MOJO.router;
-    }
-    this.isStarted = false;
-    console.log(`✨ ${this.name} destroyed`);
-  }
-  /**
-   * Build page path with params and query
-   */
-  buildPagePath(page, params, query) {
-    let path = page.route || `/${page.pageName.toLowerCase()}`;
-    Object.keys(params).forEach((key) => {
-      if (typeof params[key] === "string" || typeof params[key] === "number") {
-        path = path.replace(`:${key}`, params[key]);
-      }
-    });
-    if (query && Object.keys(query).length > 0) {
-      const queryString = new URLSearchParams(query).toString();
-      path += (path.includes("?") ? "&" : "?") + queryString;
-    }
-    return path;
-  }
-  /**
-   * Static factory method
-   */
-  /**
-   * Validate that default route has a registered page
-   */
-  validateDefaultRoute() {
-    if (!this.pageClasses.has(this.defaultRoute)) {
-      console.warn(`⚠️  Default route '${this.defaultRoute}' is not registered!`);
-      console.warn(`   Please register a page: app.registerPage('${this.defaultRoute}', YourPageClass);`);
-      console.warn(`   Or change default route: new WebApp({ defaultRoute: 'your-page' });`);
-    } else {
-      console.log(`✅ Default route '${this.defaultRoute}' is registered`);
-    }
-  }
-  /**
-   * Find any registered page to use as emergency fallback
-   */
-  findFallbackPage() {
-    const systemPages = ["404", "error", "denied"];
-    for (const [pageName] of this.pageClasses.entries()) {
-      if (!systemPages.includes(pageName)) {
-        return pageName;
-      }
-    }
-    return null;
-  }
-  static create(config = {}) {
-    return new WebApp(config);
-  }
-  /**
-   * Initialize global plugin registry for extensions
-   * Allows extensions to register components that core can use optionally
-   */
-  initPluginRegistry() {
-    if (typeof window !== "undefined") {
-      if (!window.MOJO) {
-        window.MOJO = {};
-      }
-      if (!window.MOJO.plugins) {
-        window.MOJO.plugins = {};
-      }
-      window.MOJO.app = this;
-    }
-  }
-  /**
-   * Register a plugin component
-   * @param {string} name - Plugin component name (e.g., 'ImageCropView')
-   * @param {*} component - The component/class to register
-   */
-  static registerPlugin(name, component) {
-    if (typeof window !== "undefined") {
-      if (!window.MOJO) {
-        window.MOJO = {};
-      }
-      if (!window.MOJO.plugins) {
-        window.MOJO.plugins = {};
-      }
-      window.MOJO.plugins[name] = component;
-      console.debug(`MOJO Plugin registered: ${name}`);
-    }
-  }
-}
-export {
-  EventBus as E,
-  Router as R,
-  WebApp as W
-};
-//# sourceMappingURL=WebApp-6qvqmOts.js.map