@moonitoring/nidamjs 1.0.0

package/dist/nidam.es.js

@@ -0,0 +1,1096 @@
+class x {
+  static #t = /* @__PURE__ */ new WeakSet();
+  /**
+   * Initialize feature modules in a container.
+   *
+   * @param {Object} delegator - Shared EventDelegator instance.
+   * @param {Document|Element} container - Container to scan.
+   * @param {Map|null} modules - Shared module registry.
+   * @param {Array<{selector:string, init:Function, name?:string}>} registry - Feature definitions.
+   */
+  static initialize(t, s = document, e = null, i = []) {
+    !Array.isArray(i) || i.length === 0 || i.forEach(({ selector: o, init: n, name: a }) => {
+      if (!o || typeof n != "function")
+        return;
+      s.querySelectorAll(o).forEach((d) => {
+        if (!this.#t.has(d))
+          try {
+            const c = n(d, t, e);
+            this.#t.add(d), a && c && e && typeof e.set == "function" && e.set(a, c);
+          } catch (c) {
+            console.warn(`Failed to initialize ${o}:`, c);
+          }
+      });
+    });
+  }
+}
+class b {
+  #t = /* @__PURE__ */ new Map();
+  #s;
+  #e = /* @__PURE__ */ new Map();
+  constructor(t = document) {
+    this.#s = t, this.#i();
+  }
+  #i() {
+    [
+      "click",
+      "input",
+      "change",
+      "focusin",
+      "focusout",
+      "keydown",
+      "mousedown",
+      "desktop:toggle-matrix",
+      "desktop:theme-changed"
+    ].forEach((s) => {
+      const e = (i) => this.#o(s, i);
+      this.#s.addEventListener(s, e), this.#e.set(s, e);
+    });
+  }
+  #o(t, s) {
+    const e = this.#t.get(t);
+    if (!(!e || e.length === 0))
+      for (const { selector: i, handler: o } of e) {
+        if (!i) {
+          o.call(this.#s, s, this.#s);
+          continue;
+        }
+        const n = s.target.closest(i);
+        n && o.call(n, s, n);
+      }
+  }
+  /**
+   * Register an event handler.
+   * @param {string} eventType
+   * @param {string|null} selector
+   * @param {(e: Event, target: Element|Document) => void} handler
+   * @param {{group?: string}} [options]
+   */
+  on(t, s, e, i = {}) {
+    const o = i.group;
+    this.#t.has(t) || this.#t.set(t, []);
+    const n = { selector: s, handler: e, group: o };
+    return this.#t.get(t).push(n), n;
+  }
+  off(t, s) {
+    const e = this.#t.get(t);
+    if (!e) return;
+    const i = e.indexOf(s);
+    i !== -1 && e.splice(i, 1), e.length || this.#t.delete(t);
+  }
+  destroy() {
+    for (const [t, s] of this.#e)
+      this.#s.removeEventListener(t, s);
+    this.#e.clear(), this.#t.clear();
+  }
+}
+const R = {
+  /**
+   * Move text cursor to the end of an editable element
+   * @param {HTMLElement} element - Target element
+   */
+  moveCursorToEnd(r) {
+    const t = document.createRange();
+    t.selectNodeContents(r), t.collapse(!1);
+    const s = window.getSelection();
+    s.removeAllRanges(), s.addRange(t);
+  },
+  /**
+   * Register a callback for ESC key press
+   * Automatically removes listener after first trigger
+   * @param {Function} callback - Function to call on ESC press
+   * @returns {Function} Handler function for manual removal
+   */
+  onEscape(r) {
+    const t = (s) => {
+      s.key === "Escape" && (r(), document.removeEventListener("keydown", t));
+    };
+    return document.addEventListener("keydown", t), t;
+  },
+  /**
+   * Hide elements by adding 'hidden' class
+   * @param {...HTMLElement} elements - Elements to hide
+   */
+  hide(...r) {
+    r.forEach((t) => t?.classList.add("hidden"));
+  },
+  /**
+   * Show elements by removing 'hidden' class
+   * @param {...HTMLElement} elements - Elements to show
+   */
+  show(...r) {
+    r.forEach((t) => t?.classList.remove("hidden"));
+  },
+  /**
+   * Toggle visibility of elements
+   * @param {...HTMLElement} elements - Elements to toggle
+   */
+  toggle(...r) {
+    r.forEach((t) => t?.classList.toggle("hidden"));
+  }
+};
+class z {
+  _root;
+  _elements = {};
+  _state = {};
+  _utils = R;
+  _delegator = null;
+  /**
+   * @param {HTMLElement|string} root - Root element or selector
+   * @param {EventDelegator} delegator - Global event delegator instance
+   */
+  constructor(t, s) {
+    if (this._root = typeof t == "string" ? document.querySelector(t) : t, this._delegator = s, !this._root)
+      throw new Error(`Root element not found: ${t}`);
+    this._initialize();
+  }
+  /**
+   * Initialize the manager (called automatically)
+   * @private
+   */
+  _initialize() {
+    this._elements = this._cacheElements(), this._bindEvents();
+  }
+  /**
+   * Cache DOM elements needed by this manager
+   * Override in child classes
+   * @returns {Object} Object containing DOM element references
+   * @protected
+   */
+  _cacheElements() {
+    return {};
+  }
+  /**
+   * Bind event listeners
+   * Override in child classes
+   * @protected
+   */
+  _bindEvents() {
+  }
+  /**
+   * Query a single element within the root
+   * @param {string} selector - CSS selector
+   * @returns {HTMLElement|null}
+   * @protected
+   */
+  _query(t) {
+    return this._root.querySelector(t);
+  }
+  /**
+   * Query multiple elements within the root
+   * @param {string} selector - CSS selector
+   * @returns {NodeList}
+   * @protected
+   */
+  _queryAll(t) {
+    return this._root.querySelectorAll(t);
+  }
+  /**
+   * Register scoped event handler
+   * @param {string} eventType
+   * @param {string} selector
+   * @param {Function} handler
+   * @protected
+   */
+  _on(t, s, e) {
+    this._delegator.on(t, s, (i, o) => {
+      this._root.contains(o) && e.call(this, i, o);
+    });
+  }
+}
+const W = /* @__PURE__ */ new WeakMap();
+function u(r) {
+  return !r || r === "auto" || r === "normal" ? "" : r;
+}
+function w(r) {
+  return Number.isFinite(r) ? `${Math.round(r)}px` : "";
+}
+function T(r, t = {}) {
+  const s = t.includePosition === !0;
+  let e = null;
+  const i = () => (e || (e = window.getComputedStyle(r)), e), o = (r.offsetWidth > 0 ? w(r.offsetWidth) : "") || u(r.style.width) || u(i().width), n = (r.offsetHeight > 0 ? w(r.offsetHeight) : "") || u(r.style.height) || u(i().height);
+  let a = "", l = "";
+  return s && (a = w(r.offsetLeft) || u(r.style.left) || u(i().left), l = w(r.offsetTop) || u(r.style.top) || u(i().top)), {
+    width: o || "",
+    height: n || "",
+    left: a,
+    top: l
+  };
+}
+function y(r) {
+  let t = W.get(r);
+  return t || (t = /* @__PURE__ */ new Map(), W.set(r, t)), t;
+}
+function C(r, t = "prevState", s = {}) {
+  const e = T(r, s), i = JSON.stringify(e);
+  return r.dataset[t] = i, y(r).set(t, { raw: i, parsed: e }), e;
+}
+function v(r, t = "prevState") {
+  const s = r.dataset[t];
+  if (!s) return null;
+  const e = y(r).get(t);
+  if (e && e.raw === s)
+    return e.parsed;
+  try {
+    const i = JSON.parse(s);
+    if (!i || typeof i != "object")
+      return y(r).set(t, { raw: s, parsed: null }), null;
+    const o = {
+      width: u(i.width),
+      height: u(i.height),
+      left: u(i.left),
+      top: u(i.top)
+    };
+    return y(r).set(t, { raw: s, parsed: o }), o;
+  } catch {
+    return y(r).set(t, { raw: s, parsed: null }), null;
+  }
+}
+function L(r, t, s = {}) {
+  return !t || typeof t != "object" ? !1 : (t.width && r.style.width !== t.width && (r.style.width = t.width), t.height && r.style.height !== t.height && (r.style.height = t.height), s.includePosition && (t.left && r.style.left !== t.left && (r.style.left = t.left), t.top && r.style.top !== t.top && (r.style.top = t.top)), !0);
+}
+class D extends z {
+  // Configuration
+  _config = {
+    zIndexBase: 40,
+    layoutStabilizationMs: 450,
+    cascadeOffset: 30,
+    cooldownMs: 500,
+    maxWindows: 10,
+    snapGap: 6,
+    taskbarHeight: 64,
+    snapThreshold: 30,
+    dragThreshold: 10,
+    resizeDebounceMs: 6,
+    animationDurationMs: 400,
+    defaultWidth: 800,
+    defaultHeight: 600,
+    minMargin: 10,
+    edgeDetectionRatio: 0.4,
+    scrollRestoreTimeoutMs: 2e3
+  };
+  _windows = /* @__PURE__ */ new Map();
+  _zIndexCounter = this._config.zIndexBase;
+  _getModules = null;
+  _notify = null;
+  _fetchWindowContent = null;
+  _initializeContent = null;
+  _resolveEndpoint = null;
+  _lastOpenTimestamps = /* @__PURE__ */ new Map();
+  _pendingRequests = /* @__PURE__ */ new Map();
+  // Tiling & Snapping properties
+  _snapIndicator = null;
+  constructor(t, s, e = {}) {
+    super(t, s);
+    const {
+      getModules: i = null,
+      config: o = null,
+      notify: n = null,
+      fetchWindowContent: a = null,
+      initializeContent: l = null,
+      resolveEndpoint: d = null
+    } = e || {};
+    this._getModules = i, this._notify = n || this._defaultNotify.bind(this), this._fetchWindowContent = a || this._defaultFetchWindowContent.bind(this), this._initializeContent = l || (() => {
+    }), this._resolveEndpoint = d || this._defaultResolveEndpoint, o && typeof o == "object" && (this._config = { ...this._config, ...o }), this._zIndexCounter = this._config.zIndexBase, this._initSnapIndicator();
+  }
+  // Create the visual indicator for window snapping
+  _initSnapIndicator() {
+    this._snapIndicator = document.createElement("div"), this._snapIndicator.className = "snap-indicator", document.body.appendChild(this._snapIndicator);
+  }
+  _cacheElements() {
+    return {};
+  }
+  _bindEvents() {
+    this._delegator.on(
+      "click",
+      "[data-modal]",
+      this._handleModalTrigger.bind(this)
+    ), this._delegator.on(
+      "click",
+      "[data-maximize]",
+      this._handleMaximizeTrigger.bind(this)
+    ), this._delegator.on(
+      "click",
+      "[data-close]",
+      this._handleCloseTrigger.bind(this)
+    ), this._delegator.on(
+      "mousedown",
+      ".window",
+      this._handleWindowFocus.bind(this)
+    ), this._delegator.on(
+      "mousedown",
+      "[data-bar]",
+      this._handleWindowDragStart.bind(this)
+    ), document.addEventListener("keydown", this._handleGlobalKeydown.bind(this));
+    let t;
+    window.addEventListener("resize", () => {
+      clearTimeout(t), t = setTimeout(
+        () => this._handleResize(),
+        this._config.resizeDebounceMs
+      );
+    });
+  }
+  // Event Handlers
+  _handleModalTrigger(t, s) {
+    t.preventDefault(), this.open(s.dataset.modal).catch((e) => {
+      console.debug("Modal trigger failed:", e);
+    });
+  }
+  _handleCloseTrigger(t, s) {
+    t.preventDefault();
+    const e = s.closest(".window");
+    e && this.close(e);
+  }
+  _handleWindowFocus(t, s) {
+    if (t.target.closest("[data-close]") || t.target.closest("[data-modal]"))
+      return;
+    const e = s.closest(".window");
+    e && this._focusWindow(e);
+  }
+  _handleMaximizeTrigger(t, s) {
+    t.preventDefault();
+    const e = s.closest(".window");
+    e && this.toggleMaximize(e);
+  }
+  _handleWindowDragStart(t, s) {
+    if (t.target.closest("[data-close]") || t.target.closest("[data-maximize]"))
+      return;
+    t.preventDefault();
+    const e = s.closest(".window");
+    e && (this._focusWindow(e), this.drag(t, e));
+  }
+  _handleGlobalKeydown(t) {
+    t.key === "Escape" && !t.repeat && this._closeTopmostWindow();
+  }
+  // Public Methods
+  // Toggle between maximized and normal state
+  toggleMaximize(t) {
+    const s = t.classList.contains("maximized"), e = t.classList.contains("tiled") && typeof t.dataset.snapType == "string" && t.dataset.snapType.length > 0;
+    t.classList.add("window-toggling"), !s && !t.classList.contains("tiled") && this._ensureRestoreState(t);
+    const i = t.classList.toggle("maximized");
+    let o = !1;
+    if (this._updateMaximizeIcon(t, i), !i)
+      if (e) {
+        const n = this._getSnapLayout(
+          t.dataset.snapType,
+          window.innerWidth,
+          window.innerHeight - this._config.taskbarHeight
+        );
+        Object.assign(t.style, n);
+      } else {
+        const n = v(t);
+        L(t, n);
+        const a = this._parseCssPixelValue(n?.width) || this._parseCssPixelValue(t.style.width) || t.offsetWidth, l = this._parseCssPixelValue(n?.height) || this._parseCssPixelValue(t.style.height) || t.offsetHeight;
+        this._repositionWindowFromRatios(
+          t,
+          window.innerWidth,
+          window.innerHeight,
+          {
+            widthPx: a,
+            heightPx: l
+          }
+        ), o = !0;
+      }
+    setTimeout(() => {
+      t.classList.remove("window-toggling"), o && this._savePositionRatios(t);
+    }, this._config.animationDurationMs);
+  }
+  // Open a window by its endpoint
+  async open(t, s = !1, e = null, i = !0) {
+    if (this._windows.size >= this._config.maxWindows && !this._windows.has(t)) {
+      const a = document.body.dataset.errorMaxWindows || `Maximum of ${this._config.maxWindows} windows allowed.`;
+      return this._notify("error", a.replace("%s", String(this._config.maxWindows))), Promise.reject(new Error("Max windows reached"));
+    }
+    if (this._windows.has(t) && !s) {
+      const a = this._windows.get(t);
+      return i && this._focusWindow(a), Promise.resolve(a);
+    }
+    if (this._pendingRequests.has(t))
+      return this._pendingRequests.get(t);
+    const o = Date.now();
+    if (!s && o - (this._lastOpenTimestamps.get(t) || 0) < this._config.cooldownMs)
+      return Promise.resolve();
+    this._lastOpenTimestamps.set(t, o);
+    const n = (async () => {
+      try {
+        const a = await this._fetchWindowContent(t, {
+          force: s,
+          focusSelector: e,
+          activate: i,
+          manager: this
+        });
+        if (typeof a != "string")
+          throw new TypeError("fetchWindowContent must return an HTML string");
+        if (this._windows.has(t) && s) {
+          const d = this._windows.get(t);
+          return !i && this._isWindowBusy(d) || (this._refreshWindowContent(d, a), i && this._focusWindow(d), e && this._handleFocusSelector(d, e)), d;
+        }
+        const l = this._createWindowElement(a, t);
+        if (!l) {
+          console.warn(`No .window element found for ${t}`);
+          return;
+        }
+        return this._setupNewWindow(l, t, e, i), l;
+      } catch (a) {
+        console.error("Error opening window:", a);
+        const l = document.body.dataset.errorOpenFailed || "Failed to open window.";
+        throw this._notify("error", l), a;
+      } finally {
+        this._pendingRequests.delete(t);
+      }
+    })();
+    return this._pendingRequests.set(t, n), n;
+  }
+  // Close a window
+  close(t) {
+    const s = t.dataset.endpoint;
+    this._windows.get(s) === t && this._windows.delete(s), t.classList.add("animate-disappearance"), t.classList.remove("animate-appearance"), t.addEventListener(
+      "animationend",
+      () => {
+        t.isConnected && t.remove();
+      },
+      { once: !0 }
+    );
+  }
+  // Internal Logic
+  // Focus a window and bring it to top
+  _focusWindow(t) {
+    this._zIndexCounter++, t.style.zIndex = this._zIndexCounter, t.classList.add("focused"), this._windows.forEach((s) => {
+      s !== t && s.classList.remove("focused");
+    });
+  }
+  _isWindowBusy(t) {
+    return t.dataset.isBusy === "true" ? !0 : t.querySelector('[data-is-busy="true"]') !== null;
+  }
+  _refreshWindowContent(t, s) {
+    const o = (
+      /** @type {HTMLElement|null} */
+      new DOMParser().parseFromString(s, "text/html").querySelector(".window")
+    );
+    if (!o) return;
+    const n = t.dataset.snapType, a = t.dataset.prevState, l = t.dataset.xRatio, d = t.dataset.yRatio, c = t.classList.contains("focused"), h = t.classList.contains("maximized"), f = t.classList.contains("tiled"), g = this._captureScrollState(t);
+    t.innerHTML = o.innerHTML, t.className = o.className, n && (t.dataset.snapType = n), a && (t.dataset.prevState = a), l && (t.dataset.xRatio = l), d && (t.dataset.yRatio = d), c && t.classList.add("focused"), f && t.classList.add("tiled"), h && (t.classList.add("maximized"), this._updateMaximizeIcon(t, !0)), !f && !h && (o.style.width && (t.style.width = o.style.width), o.style.height && (t.style.height = o.style.height)), t.style.margin = "0", t.style.transform = "none", this._restoreScrollState(t, g), this._initializeModalContent(t);
+  }
+  _updateMaximizeIcon(t, s) {
+    const e = t.querySelector("[data-maximize] i");
+    e && (e.classList.toggle("fa-expand", !s), e.classList.toggle("fa-compress", s));
+  }
+  _createWindowElement(t, s) {
+    const o = (
+      /** @type {HTMLElement|null} */
+      new DOMParser().parseFromString(t, "text/html").querySelector(".window")
+    );
+    return o && (o.dataset.endpoint = s), o;
+  }
+  _setupNewWindow(t, s, e, i = !0) {
+    Object.assign(t.style, {
+      position: "absolute",
+      pointerEvents: "auto",
+      margin: "0",
+      transform: "none",
+      visibility: "hidden"
+    }), this._root.appendChild(t);
+    const o = this._windows.size, n = t.dataset.defaultSnap;
+    if (n) {
+      const a = window.innerWidth, l = window.innerHeight - this._config.taskbarHeight;
+      this._snapWindow(t, n, a, l);
+    } else
+      this._positionWindow(t, o), this._ensureRestoreState(t);
+    this._windows.set(s, t), this._initializeModalContent(t), i && this._focusWindow(t), t.style.visibility = "", n || this._stabilizeInitialPlacement(t, o), e && this._handleFocusSelector(t, e);
+  }
+  _positionWindow(t, s = null) {
+    const e = t.offsetWidth || parseInt(t.style.width) || this._config.defaultWidth, i = t.offsetHeight || parseInt(t.style.height) || this._config.defaultHeight, o = window.innerWidth, n = window.innerHeight, a = Number.isFinite(s) && s >= 0 ? s : this._windows.size, l = a * this._config.cascadeOffset, d = a * this._config.cascadeOffset;
+    let c = (o - e) / 2 + l, h = (n - i) / 2 + d;
+    const f = this._config.minMargin;
+    c + e > o && (c = Math.max(f, o - e - f)), h + i > n && (h = Math.max(f, n - i - f)), t.style.left = `${Math.round(c)}px`, t.style.top = `${Math.round(h)}px`, this._savePositionRatios(t);
+  }
+  _stabilizeInitialPlacement(t, s) {
+    if (!t?.isConnected) return;
+    const e = Number.isFinite(this._config.layoutStabilizationMs) && this._config.layoutStabilizationMs > 0 ? this._config.layoutStabilizationMs : 450, i = typeof performance < "u" ? () => performance.now() : () => Date.now(), o = i();
+    let n = !0, a = null, l = t.offsetWidth, d = t.offsetHeight;
+    const c = () => {
+      n && (n = !1, a && (a.disconnect(), a = null));
+    }, h = () => {
+      if (!n || !t.isConnected) {
+        c();
+        return;
+      }
+      if (t.classList.contains("tiled") || t.classList.contains("maximized"))
+        return;
+      const g = t.offsetWidth, _ = t.offsetHeight;
+      (g !== l || _ !== d) && (l = g, d = _, this._positionWindow(t, s));
+    }, f = () => {
+      if (n) {
+        if (h(), i() - o < e) {
+          requestAnimationFrame(f);
+          return;
+        }
+        c();
+      }
+    };
+    requestAnimationFrame(f), typeof ResizeObserver == "function" && (a = new ResizeObserver(() => h()), a.observe(t)), setTimeout(() => c(), e);
+  }
+  // Save relative position ratios (Center-based)
+  _savePositionRatios(t) {
+    if (t.classList.contains("tiled") || t.classList.contains("maximized"))
+      return;
+    const s = t.offsetLeft + t.offsetWidth / 2, e = t.offsetTop + t.offsetHeight / 2;
+    t.dataset.xRatio = String(s / window.innerWidth), t.dataset.yRatio = String(e / window.innerHeight);
+  }
+  _ensureRestoreState(t) {
+    const s = v(t);
+    return s?.width && s?.height ? s : C(t, "prevState", { includePosition: !1 });
+  }
+  _parseCssPixelValue(t) {
+    if (!t) return null;
+    const s = parseFloat(t);
+    return Number.isFinite(s) ? s : null;
+  }
+  _repositionWindowFromRatios(t, s, e, i = null) {
+    const o = parseFloat(t.dataset.xRatio), n = parseFloat(t.dataset.yRatio);
+    if (isNaN(o) || isNaN(n)) return !1;
+    const a = (i && Number.isFinite(i.widthPx) && i.widthPx > 0 ? i.widthPx : null) || t.offsetWidth, l = (i && Number.isFinite(i.heightPx) && i.heightPx > 0 ? i.heightPx : null) || t.offsetHeight, d = o * s, c = n * e;
+    return t.style.left = `${Math.round(d - a / 2)}px`, t.style.top = `${Math.round(c - l / 2)}px`, !0;
+  }
+  _handleFocusSelector(t, s) {
+    const e = t.querySelector(s);
+    e && ((e.type === "radio" || e.type === "checkbox") && (e.checked = !0), e.focus());
+  }
+  _closeTopmostWindow() {
+    let t = null, s = 0;
+    this._windows.forEach((e) => {
+      if (e.classList.contains("animate-disappearance")) return;
+      const i = parseInt(e.style.zIndex || 0, 10);
+      i > s && (s = i, t = e);
+    }), t && this.close(t);
+  }
+  // Drag & Tiling Methods
+  drag(t, s) {
+    this._dragState?.active || (this._dragState = {
+      active: !0,
+      winElement: s,
+      startX: t.clientX,
+      startY: t.clientY,
+      currentX: t.clientX,
+      currentY: t.clientY,
+      startWinLeft: s.offsetLeft,
+      startWinTop: s.offsetTop,
+      isRestored: !1,
+      restoreXRatio: null,
+      initialState: {
+        tiled: s.classList.contains("tiled"),
+        maximized: s.classList.contains("maximized")
+      },
+      view: {
+        w: window.innerWidth,
+        h: window.innerHeight - this._config.taskbarHeight
+      },
+      snap: null,
+      inhibitSnap: !1,
+      isDragging: !1
+    }, this._dragHandlers = {
+      move: (e) => {
+        this._dragState.currentX = e.clientX, this._dragState.currentY = e.clientY;
+      },
+      stop: () => this._handleDragStop()
+    }, document.addEventListener("mousemove", this._dragHandlers.move, {
+      passive: !0
+    }), document.addEventListener("mouseup", this._dragHandlers.stop), requestAnimationFrame(() => this._dragLoop()));
+  }
+  _dragLoop() {
+    this._dragState?.active && (this._updateDragPosition(), requestAnimationFrame(() => this._dragLoop()));
+  }
+  _updateDragPosition() {
+    const t = this._dragState, { winElement: s, currentX: e, currentY: i, startX: o, startY: n } = t, a = e - o, l = i - n;
+    if (!t.isDragging && (Math.abs(a) > this._config.dragThreshold || Math.abs(l) > this._config.dragThreshold) && (t.isDragging = !0), !t.isDragging) return;
+    (t.initialState.tiled || t.initialState.maximized) && !t.isRestored && t.isDragging && (t.initialState.maximized ? (t.restoreXRatio = o / window.innerWidth, this._restoreWindowInternal(s, t.restoreXRatio), t.startWinTop = 0) : (t.restoreXRatio = (o - s.offsetLeft) / s.offsetWidth, this._restoreWindowInternal(s, null), t.startWinTop = s.offsetTop), t.startX = e, t.startY = i, t.isRestored = !0);
+    let d, c;
+    if (t.isRestored && t.restoreXRatio !== null) {
+      const h = s.offsetWidth;
+      d = e - t.restoreXRatio * h, c = Math.max(0, t.startWinTop + (i - n));
+    } else
+      d = t.startWinLeft + (t.isRestored ? e - t.startX : a), c = Math.max(
+        0,
+        t.startWinTop + (t.isRestored ? i - t.startY : l)
+      );
+    s.style.left = `${d}px`, s.style.top = `${c}px`, (t.isRestored || !t.initialState.tiled && !t.initialState.maximized) && (s.classList.contains("tiled") && s.classList.remove("tiled"), s.classList.contains("maximized") && (s.classList.remove("maximized"), this._updateMaximizeIcon(s, !1))), t.isDragging && this._detectSnapZone(e, i);
+  }
+  _detectSnapZone(t, s) {
+    const { view: e } = this._dragState, i = this._config.snapThreshold, o = e.w * this._config.edgeDetectionRatio, n = e.h * this._config.edgeDetectionRatio;
+    let a = null;
+    s < i ? t < o ? a = "tl" : t > e.w - o ? a = "tr" : a = "maximize" : t < i ? s < n ? a = "tl" : s > e.h - n ? a = "bl" : a = "left" : t > e.w - i ? s < n ? a = "tr" : s > e.h - n ? a = "br" : a = "right" : s > e.h - i && (a = t < e.w / 2 ? "bl" : "br"), this._dragState.snap !== a && (this._dragState.snap = a, this._updateSnapIndicator(a, e.w, e.h));
+  }
+  _handleDragStop() {
+    if (!this._dragState?.active) return;
+    const { winElement: t, snap: s, view: e } = this._dragState;
+    document.removeEventListener("mousemove", this._dragHandlers.move), document.removeEventListener("mouseup", this._dragHandlers.stop), this._snapIndicator.classList.remove("visible"), s ? s === "maximize" ? this.toggleMaximize(t) : this._snapWindow(t, s, e.w, e.h) : this._savePositionRatios(t), this._dragState.active = !1, this._dragState = null, this._dragHandlers = null;
+  }
+  // Unified Restore Logic
+  _restoreWindowInternal(t, s) {
+    let e, i;
+    const o = v(t);
+    s === null ? o && (e = o.width, i = o.height) : (e = o?.width || t.style.width, i = o?.height || t.style.height), (!e || e === "100%") && (e = this._config.defaultWidth + "px"), (!i || i === "100%") && (i = this._config.defaultHeight + "px"), t.classList.remove("maximized", "tiled"), this._updateMaximizeIcon(t, !1), t.classList.add("window-toggling", "dragging-restore"), L(t, { width: e, height: i }), setTimeout(() => {
+      t.classList.remove("window-toggling", "dragging-restore"), this._savePositionRatios(t);
+    }, this._config.animationDurationMs);
+  }
+  // Update snap indicator visibility and position
+  _updateSnapIndicator(t, s, e) {
+    if (!t) {
+      this._snapIndicator.classList.remove("visible");
+      return;
+    }
+    let i;
+    t === "maximize" ? i = {
+      top: "0px",
+      left: "0px",
+      width: `${s}px`,
+      height: `${e}px`
+    } : i = this._getSnapLayout(t, s, e), Object.assign(this._snapIndicator.style, i), this._snapIndicator.classList.add("visible");
+  }
+  // Snap window to a specific quadrant
+  _snapWindow(t, s, e, i) {
+    t.classList.contains("tiled") || this._ensureRestoreState(t), t.classList.add("window-toggling", "tiled"), t.dataset.snapType = s;
+    const o = this._getSnapLayout(s, e, i);
+    Object.assign(t.style, o), setTimeout(
+      () => t.classList.remove("window-toggling"),
+      this._config.animationDurationMs
+    );
+  }
+  // Calculate dimensions and position for a snap quadrant
+  _getSnapLayout(t, s, e) {
+    const i = this._config.snapGap, o = (s - i * 3) / 2, n = (e - i * 3) / 2, a = e - i * 2, l = i, d = o + i * 2, c = i, h = n + i * 2, g = {
+      // Quadrants
+      tl: { top: c, left: l, width: o, height: n },
+      tr: { top: c, left: d, width: o, height: n },
+      bl: { top: h, left: l, width: o, height: n },
+      br: { top: h, left: d, width: o, height: n },
+      // Vertical Splits
+      left: { top: c, left: l, width: o, height: a },
+      right: { top: c, left: d, width: o, height: a }
+    }[t];
+    return {
+      width: `${g.width}px`,
+      height: `${g.height}px`,
+      top: `${g.top}px`,
+      left: `${g.left}px`
+    };
+  }
+  // Handle browser window resize to keep tiled windows in place
+  _handleResize() {
+    const t = window.innerWidth, s = window.innerHeight, e = s - this._config.taskbarHeight;
+    this._windows.forEach((i) => {
+      if (i.classList.contains("tiled") && i.dataset.snapType) {
+        const o = i.dataset.snapType, n = this._getSnapLayout(o, t, e);
+        Object.assign(i.style, n);
+      } else i.classList.contains("maximized") || this._repositionWindowFromRatios(i, t, s);
+    });
+  }
+  // Capture scroll positions of an element and its descendants
+  _captureScrollState(t) {
+    const s = /* @__PURE__ */ new Map();
+    return (t.scrollTop > 0 || t.scrollLeft > 0) && s.set("root", {
+      top: t.scrollTop,
+      left: t.scrollLeft
+    }), t.querySelectorAll("*").forEach((e) => {
+      (e.scrollTop > 0 || e.scrollLeft > 0) && s.set(this._getElementPath(t, e), {
+        top: e.scrollTop,
+        left: e.scrollLeft
+      });
+    }), s;
+  }
+  // Restore scroll positions and observe layout shifts for stabilization
+  _restoreScrollState(t, s) {
+    const e = () => {
+      s.forEach((n, a) => {
+        let l;
+        if (a === "root")
+          l = t;
+        else
+          try {
+            l = t.querySelector(`:scope > ${a}`);
+          } catch {
+            l = t.querySelector(a);
+          }
+        l && (l.scrollTop = n.top, l.scrollLeft = n.left);
+      });
+    };
+    e();
+    const i = t.querySelector(".window-content-scrollable > div") || t, o = new ResizeObserver(() => e());
+    o.observe(i), setTimeout(
+      () => o.disconnect(),
+      this._config.scrollRestoreTimeoutMs
+    );
+  }
+  // Generate unique CSS path for an element relative to window
+  _getElementPath(t, s) {
+    let e = [], i = s;
+    for (; i && i !== t; ) {
+      let o = Array.prototype.indexOf.call(
+        i.parentNode.children,
+        i
+      );
+      e.unshift(`${i.tagName}:nth-child(${o + 1})`), i = i.parentNode;
+    }
+    return e.join(" > ");
+  }
+  async _defaultFetchWindowContent(t) {
+    return (await fetch(this._resolveEndpoint(t), {
+      headers: { "X-Modal-Request": "1" },
+      cache: "no-cache"
+    })).text();
+  }
+  _defaultResolveEndpoint(t) {
+    return `/${String(t || "").replace(/^\/+/, "")}`;
+  }
+  _defaultNotify(t, s) {
+    (t === "error" ? console.error : console.log)(`[nidamjs:${t}]`, s);
+  }
+  _initializeModalContent(t) {
+    const s = this._getModules ? this._getModules() : null;
+    this._initializeContent(t, {
+      delegator: this._delegator,
+      modules: s,
+      manager: this
+    });
+  }
+}
+class I {
+  #t;
+  #s;
+  #e = 200;
+  constructor(t, { refreshMap: s = null, refreshTimeout: e = 200 } = {}) {
+    this.#t = t, this.#s = s || window.window_refresh_map || {}, this.#e = e;
+  }
+  setRefreshMap(t = {}) {
+    this.#s = t || {};
+  }
+  handleEvent(t, s) {
+    const e = this.#s[t], [i, o] = t.split(":"), n = o === "deleted", a = s?.id || null;
+    this.#t && Array.from(this.#t._windows.entries()).forEach(
+      ([l, d]) => {
+        const c = l.startsWith("/") ? l.slice(1) : l;
+        if (n && a && d.dataset.dependsOn && d.dataset.dependsOn.split("|").some((g) => {
+          const [_, m] = g.split(":");
+          return i === _ && String(m) === String(a);
+        })) {
+          setTimeout(() => {
+            this.#t.close(d);
+          }, this.#e);
+          return;
+        }
+        e && e.forEach((h) => {
+          this.#i(
+            h,
+            c,
+            n ? null : a
+          ) && setTimeout(() => {
+            this.#t.open(l, !0, null, !1);
+          }, this.#e);
+        });
+      }
+    );
+  }
+  /**
+   * Matches a route pattern against an actual path with strict validation.
+   *
+   * Rules:
+   * 1. Exact Match: "team" matches "team", but NOT "team/5" (length mismatch).
+   * 2. Wildcard (*): "team/*" matches "team/5", "team/12/details", etc.
+   * 3. Parameters ({param}): "team/{id}" matches "team/5".
+   *    - If entityId is provided, it MUST match the parameter value (e.g. entityId "5" matches "team/5", but not "team/12").
+   *    - Parameter syntax must be enclosed in braces: {id}.
+   *
+   * @param {string} pattern - The route pattern from configuration.
+   * @param {string} path - The actual window endpoint path.
+   * @param {string|null} entityId - Optional ID to enforce specific parameter matching.
+   */
+  #i(t, s, e = null) {
+    if (t === s) return !0;
+    const i = t.split("/"), o = s.split("/");
+    return !(i[i.length - 1] === "*") && i.length !== o.length ? !1 : i.every((a, l) => a === "*" ? !0 : a.startsWith("{") && a.endsWith("}") ? e !== null ? String(o[l]) === String(e) : !0 : a === o[l]);
+  }
+}
+const H = (r, t) => {
+  (r === "error" ? console.error : console.log)(`[nidamjs:${r}]`, t);
+};
+class P {
+  #t;
+  #s = /* @__PURE__ */ new Map();
+  #e = null;
+  constructor(t = {}) {
+    this.#t = {
+      root: document,
+      modalContainer: "#target",
+      pendingModalDatasetKey: "pendingModal",
+      registry: [],
+      refreshMap: null,
+      refreshTimeout: 200,
+      notify: H,
+      windowManager: {},
+      ...t
+    };
+  }
+  initialize() {
+    return this.#i(), this.#o(), this.#r(), this;
+  }
+  getModule(t) {
+    return this.#s.get(t);
+  }
+  getModules() {
+    return this.#s;
+  }
+  #i() {
+    this.#e = new b(this.#t.root), this.#s.set("delegator", this.#e);
+  }
+  #o() {
+    const t = this.#t.root.querySelector(
+      this.#t.modalContainer
+    );
+    if (!t)
+      return;
+    const s = new D(t, this.#e, {
+      getModules: () => this.#s,
+      initializeContent: (i, o) => x.initialize(
+        o.delegator,
+        i,
+        o.modules,
+        this.#t.registry
+      ),
+      notify: this.#t.notify,
+      ...this.#t.windowManager || {}
+    });
+    this.#s.set("window", s), this.#a(t, s);
+    const e = new I(s, {
+      refreshMap: this.#t.refreshMap,
+      refreshTimeout: this.#t.refreshTimeout
+    });
+    this.#s.set("refresher", e);
+  }
+  #a(t, s) {
+    const e = this.#t.pendingModalDatasetKey, i = (t?.dataset?.[e] || "").trim();
+    if (!i)
+      return;
+    const o = i.startsWith("/") ? i.slice(1) : i;
+    s.open(o);
+  }
+  #r() {
+    x.initialize(
+      this.#e,
+      this.#t.root,
+      this.#s,
+      this.#t.registry
+    );
+  }
+}
+const $ = (r = {}) => new P(r), M = {
+  /**
+   * Saves a value to localStorage. Automatically stringifies objects/arrays.
+   * @param {string} key
+   * @param {*} value
+   */
+  set(r, t) {
+    try {
+      const s = JSON.stringify(t);
+      localStorage.setItem(r, s);
+    } catch (s) {
+      console.error(`Error saving to localStorage (key: ${r}):`, s);
+    }
+  },
+  /**
+   * Retrieves a value from localStorage. Automatically parses JSON.
+   * @param {string} key
+   * @param {*} defaultValue - Returned if the key doesn't exist or on error.
+   * @returns {*}
+   */
+  get(r, t = null) {
+    try {
+      const s = localStorage.getItem(r);
+      return s === null ? t : JSON.parse(s);
+    } catch (s) {
+      return console.error(`Error reading from localStorage (key: ${r}):`, s), t;
+    }
+  },
+  /**
+   * Removes a specific item from localStorage.
+   * @param {string} key
+   */
+  remove(r) {
+    try {
+      localStorage.removeItem(r);
+    } catch (t) {
+      console.error(`Error removing from localStorage (key: ${r}):`, t);
+    }
+  },
+  /**
+   * Clears ALL items from localStorage for this domain.
+   */
+  clear() {
+    try {
+      localStorage.clear();
+    } catch (r) {
+      console.error("Error clearing localStorage:", r);
+    }
+  },
+  /**
+   * Checks if a key exists in localStorage.
+   * @param {string} key
+   * @returns {boolean}
+   */
+  has(r) {
+    try {
+      return localStorage.getItem(r) !== null;
+    } catch {
+      return !1;
+    }
+  }
+};
+class X extends z {
+  _dragState = null;
+  _storageKey = "desktop_grid_layout";
+  _storageNamespace = "";
+  _storage = M;
+  constructor(t, s, e = {}) {
+    super(t, s), this._storageKey = e.storageKey || this._storageKey, this._storageNamespace = e.storageNamespace || "", this._storage = e.storage || M, this._loadLayout();
+  }
+  _getStorageKey() {
+    return this._storageNamespace ? `${this._storageNamespace}_${this._storageKey}` : this._storageKey;
+  }
+  _loadLayout() {
+    try {
+      const t = this._getStorageKey(), s = this._storage.get(t, []);
+      if (!s || !Array.isArray(s)) return;
+      /** @type {NodeListOf<HTMLElement>} */
+      this._root.querySelectorAll(".desktop-icon").forEach((i) => {
+        const o = i.dataset.modal, n = s.find((a) => a.id === o);
+        if (o && n && Array.isArray(n.classes)) {
+          const a = Array.from(i.classList).filter(
+            (l) => l.startsWith("col-start-") || l.startsWith("row-start-") || l.startsWith("col-end-")
+          );
+          i.classList.remove(...a), i.classList.add(...n.classes);
+        }
+      });
+    } catch (t) {
+      console.error("Failed to load desktop layout", t);
+    }
+  }
+  _bindEvents() {
+    this._delegator.on(
+      "mousedown",
+      ".desktop-icon",
+      this._handleDragStart.bind(this)
+    );
+  }
+  _handleDragStart(t, s) {
+    if (t.button !== 0) return;
+    t.preventDefault();
+    const e = s.closest(".desktop-icon"), i = e.getBoundingClientRect(), o = this._root.getBoundingClientRect(), n = Array.from(e.classList).filter(
+      (a) => a.startsWith("col-start-") || a.startsWith("row-start-") || a.startsWith("col-end-")
+    );
+    this._dragState = {
+      element: e,
+      startX: t.clientX,
+      startY: t.clientY,
+      initialLeft: i.left - o.left,
+      initialTop: i.top - o.top,
+      containerRect: o,
+      originalClasses: n
+    }, e.style.left = `${this._dragState.initialLeft}px`, e.style.top = `${this._dragState.initialTop}px`, e.style.width = `${i.width}px`, e.style.position = "absolute", e.classList.remove(...n), e.classList.add("dragging"), this._dragHandlers = {
+      move: this._handleDragMove.bind(this),
+      stop: this._handleDragStop.bind(this)
+    }, document.addEventListener("mousemove", this._dragHandlers.move), document.addEventListener("mouseup", this._dragHandlers.stop);
+  }
+  _handleDragMove(t) {
+    if (!this._dragState) return;
+    const { element: s, startX: e, startY: i, initialLeft: o, initialTop: n, containerRect: a } = this._dragState, l = t.clientX - e, d = t.clientY - i;
+    let c = o + l, h = n + d;
+    const f = a.width - s.offsetWidth, g = a.height - s.offsetHeight;
+    c = Math.max(0, Math.min(c, f)), h = Math.max(0, Math.min(h, g)), s.style.left = `${c}px`, s.style.top = `${h}px`;
+  }
+  _handleDragStop(t) {
+    if (!this._dragState) return;
+    const { element: s, startX: e, startY: i, originalClasses: o } = this._dragState, n = Math.abs(t.clientX - e), a = Math.abs(t.clientY - i), l = n > 5 || a > 5;
+    if (s.classList.remove("dragging"), s.style.zIndex = "", l) {
+      const d = (c) => {
+        c.preventDefault(), c.stopPropagation();
+      };
+      s.addEventListener("click", d, {
+        capture: !0,
+        once: !0
+      }), this._snapToGrid(s);
+    } else
+      s.style.position = "", s.style.left = "", s.style.top = "", s.style.width = "", s.classList.add(...o);
+    this._saveLayout && this._saveLayout(), document.removeEventListener("mousemove", this._dragHandlers.move), document.removeEventListener("mouseup", this._dragHandlers.stop), this._dragState = null;
+  }
+  _snapToGrid(t) {
+    const s = this._root.getBoundingClientRect(), e = t.getBoundingClientRect();
+    let i = 2;
+    window.innerWidth >= 1280 ? i = 10 : window.innerWidth >= 1024 ? i = 8 : window.innerWidth >= 768 && (i = 6);
+    const o = 3, n = s.width / i, a = s.height / o, l = e.left - s.left + e.width / 2, d = e.top - s.top + e.height / 2;
+    let c = Math.floor(l / n) + 1, h = Math.floor(d / a) + 1;
+    c = Math.max(1, Math.min(c, i)), h = Math.max(1, Math.min(h, o));
+    const f = `col-start-${c}`, g = `row-start-${h}`;
+    if (Array.from(
+      /** @type {NodeListOf<HTMLElement>} */
+      this._root.querySelectorAll(".desktop-icon")
+    ).find(
+      (p) => p !== t && p.classList.contains(f) && p.classList.contains(g)
+    )) {
+      if (t.style.position = "", t.style.left = "", t.style.top = "", t.style.width = "", this._dragState && this._dragState.originalClasses) {
+        const p = Array.from(t.classList).filter(
+          (S) => S.startsWith("col-start-") || S.startsWith("row-start-") || S.startsWith("col-end-")
+        );
+        t.classList.remove(...p), t.classList.add(...this._dragState.originalClasses);
+      }
+      return;
+    }
+    t.style.position = "", t.style.left = "", t.style.top = "", t.style.width = "";
+    const m = Array.from(t.classList).filter(
+      (p) => p.startsWith("col-start-") || p.startsWith("row-start-") || p.startsWith("col-end-")
+    );
+    t.classList.remove(...m), t.classList.add(f, g);
+  }
+  _saveLayout() {
+    const t = [];
+    /** @type {NodeListOf<HTMLElement>} */
+    this._root.querySelectorAll(".desktop-icon").forEach((i) => {
+      const o = i.dataset.modal;
+      if (o) {
+        const n = Array.from(i.classList).filter(
+          (a) => a.startsWith("col-start-") || a.startsWith("row-start-")
+        );
+        t.push({
+          id: o,
+          classes: n
+        });
+      }
+    });
+    const e = this._getStorageKey();
+    this._storage.set(e, t);
+  }
+}
+function A(r, t) {
+  if (!r || !t || t.type !== "success" || !t.emit)
+    return;
+  let s = t.emit, e = t.id || null;
+  const i = s.split(":");
+  i.length >= 3 && (e = i.pop(), s = i.join(":")), r.handleEvent(s, { ...t, emit: s, id: e });
+}
+const N = $();
+N.initialize();
+export {
+  z as BaseManager,
+  x as ContentInitializer,
+  R as DOMUtils,
+  X as DesktopIconManager,
+  b as EventDelegator,
+  P as NidamApp,
+  D as WindowManager,
+  I as WindowRefresher,
+  L as applyWindowState,
+  T as captureWindowState,
+  $ as createNidamApp,
+  A as handleRefreshEvent,
+  v as readWindowState,
+  C as saveWindowState,
+  M as storageUtil
+};