web-mojo 2.1.1043 → 2.1.1087

package/dist/chunks/{Dialog-BiVgKzSK.js → Dialog-DHUsZ92-.js}

@@ -1,4 +1,1361 @@
-import { V as View } from "./Rest-CS4jRCAs.js";
+import { r as rest, V as View } from "./Rest-DpbPbmra.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;
+      }
+      this.events.emit("page:showing", {
+        page: pageInstance,
+        pageName: pageInstance.pageName,
+        params,
+        query,
+        fromRouter
+      });
+      const oldPage = this.currentPage;
+      if (!pageInstance) {
+        this._show404(pageName, params, query, fromRouter);
+        return;
+      }
+      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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      await Dialog2.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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      await Dialog2.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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      await Dialog2.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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      await Dialog2.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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      Dialog2.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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      Dialog2.hideBusy();
+    } catch (e) {
+      if (typeof window !== "undefined" && window?.console) {
+        console.warn("[WebApp] hideLoading fallback:", e);
+      }
+    }
+  }
+  async showModelForm(options = {}) {
+    try {
+      const Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      return await Dialog2.showModelForm(options);
+    } catch (e) {
+      if (typeof window !== "undefined" && window?.console) {
+        console.error("[WebApp] showModelForm failed:", e);
+      }
+      throw e;
+    }
+  }
+  async showForm(options = {}) {
+    try {
+      const Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      return await Dialog2.showForm(options);
+    } catch (e) {
+      if (typeof window !== "undefined" && window?.console) {
+        console.error("[WebApp] showForm failed:", e);
+      }
+      throw e;
+    }
+  }
+  async showDialog(options = {}) {
+    try {
+      const Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+      return await Dialog2.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 Dialog2 = (await Promise.resolve().then(() => Dialog$1)).default;
+    return await Dialog2.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}`);
+    }
+  }
+}
 class Dialog extends View {
   static _openDialogs = [];
   static _baseZIndex = {
@@ -248,8 +1605,11 @@ class Dialog extends View {
     if (this.size && this.size !== "auto") {
       if (this.size.startsWith("fullscreen")) {
         dialogClasses.push(`modal-${this.size}`);
-      } else if (["sm", "lg", "xl"].includes(this.size)) {
+      } else if (["sm", "lg", "xl", "xxl"].includes(this.size)) {
         dialogClasses.push(`modal-${this.size}`);
+        if (["lg", "xl", "xxl"].includes(this.size)) {
+          dialogClasses.push("modal-fullscreen-sm-down");
+        }
       }
     }
     if (this.centered) {
@@ -1165,7 +2525,7 @@ class Dialog extends View {
       cancelText = "Cancel",
       ...dialogOptions
     } = options;
-    const FormView = (await import("./FormView-BClEkzmE.js").then((n) => n.b)).default;
+    const FormView = (await import("./FormView-DGRmcKUG.js").then((n) => n.b)).default;
     const formView = new FormView({
       fileHandling: options.fileHandling || "base64",
       data: options.data,
@@ -1270,7 +2630,7 @@ class Dialog extends View {
     if (!model) {
       throw new Error("showModelForm requires a model");
     }
-    const FormView = (await import("./FormView-BClEkzmE.js").then((n) => n.b)).default;
+    const FormView = (await import("./FormView-DGRmcKUG.js").then((n) => n.b)).default;
     const formView = new FormView({
       fileHandling: options.fileHandling || "base64",
       model,
@@ -1370,7 +2730,7 @@ class Dialog extends View {
       closeText = "Close",
       ...dialogOptions
     } = options;
-    const DataView = (await import("./DataView-OUqaLmGB.js")).default;
+    const DataView = (await import("./DataView-QXyfcg2M.js")).default;
     const dataView = new DataView({
       data,
       model,
@@ -1430,7 +2790,15 @@ class Dialog extends View {
 }
 Dialog.showConfirm = Dialog.confirm;
 Dialog.showError = Dialog.alert;
+const Dialog$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: Dialog
+}, Symbol.toStringTag, { value: "Module" }));
 export {
-  Dialog as default
+  Dialog as D,
+  EventBus as E,
+  Router as R,
+  WebApp as W,
+  Dialog$1 as a
 };
-//# sourceMappingURL=Dialog-BiVgKzSK.js.map
+//# sourceMappingURL=Dialog-DHUsZ92-.js.map