@surdeddd/wmkit 0.5.1 → 0.6.1

package/dist/{chunk-C2UHNBSA.cjs → chunk-DYZQY3BE.cjs}

@@ -195,6 +195,12 @@ function createWindowManager(options = {}) {
   const idPrefix = options.idPrefix ?? "wm";
   const historyLimit = options.historyLimit ?? 50;
   let windows = {};
+  let windowsShared = false;
+  let modalCount = 0;
+  let cachedGroups = null;
+  let cachedOrder = null;
+  let cachedTabs = null;
+  let groupsDirty = false;
   let order = [];
   let focusedId = null;
   let viewport = options.viewport ?? { width: 0, height: 0 };
@@ -219,6 +225,7 @@ function createWindowManager(options = {}) {
   const layouts = /* @__PURE__ */ new Map();
   function getState() {
     if (!snapshot) {
+      windowsShared = true;
       snapshot = { windows, order, focusedId, viewport, workspace, groups: buildGroups() };
     }
     return snapshot;
@@ -240,14 +247,36 @@ function createWindowManager(options = {}) {
   function queueEvent(emit) {
     pendingEvents.push(emit);
   }
+  function ownWindows() {
+    if (windowsShared) {
+      windows = { ...windows };
+      windowsShared = false;
+    }
+    return windows;
+  }
   function setWindow(next) {
-    windows = { ...windows, [next.id]: next };
+    const map = ownWindows();
+    const previous = map[next.id];
+    const wasModal = previous?.layer === "modal";
+    if (wasModal !== (next.layer === "modal")) modalCount += wasModal ? -1 : 1;
+    if (previous?.groupId !== next.groupId) groupsDirty = true;
+    map[next.id] = next;
   }
   function removeWindow(id) {
-    const { [id]: _removed, ...rest } = windows;
-    windows = rest;
+    const map = ownWindows();
+    const previous = map[id];
+    if (previous?.layer === "modal") modalCount -= 1;
+    if (previous?.groupId != null) groupsDirty = true;
+    delete map[id];
     order = order.filter((entry) => entry !== id);
   }
+  function countModals() {
+    let total = 0;
+    for (const id of order) {
+      if (windows[id].layer === "modal") total += 1;
+    }
+    return total;
+  }
   function layerRankOf(id) {
     return LAYER_RANK[windows[id].layer];
   }
@@ -284,31 +313,57 @@ function createWindowManager(options = {}) {
     return win.groupId === null || activeTabs[win.groupId] === win.id;
   }
   function buildGroups() {
+    if (cachedGroups && !groupsDirty && cachedOrder === order && cachedTabs === activeTabs) {
+      return cachedGroups;
+    }
     const result = /* @__PURE__ */ Object.create(null);
     for (const [groupId, activeId] of Object.entries(activeTabs)) {
       result[groupId] = { id: groupId, activeId, members: membersOf(groupId) };
     }
+    cachedGroups = result;
+    cachedOrder = order;
+    cachedTabs = activeTabs;
+    groupsDirty = false;
     return result;
   }
+  function sharedSize(ids, size) {
+    let shared = size;
+    for (const id of ids) {
+      const fit = normalizeSize(shared, windows[id]);
+      shared = {
+        width: Math.max(shared.width, fit.width),
+        height: Math.max(shared.height, fit.height)
+      };
+    }
+    return shared;
+  }
   function syncGroup(source) {
-    if (source.groupId === null) return;
-    for (const id of membersOf(source.groupId)) {
-      if (id === source.id) continue;
+    if (source.groupId === null) return source;
+    const members = membersOf(source.groupId);
+    const fitted = sharedSize(members, source.bounds);
+    let effective = source;
+    if (fitted.width !== source.bounds.width || fitted.height !== source.bounds.height) {
+      effective = { ...source, bounds: { ...source.bounds, ...fitted } };
+      setWindow(effective);
+    }
+    for (const id of members) {
+      if (id === effective.id) continue;
       const member = windows[id];
-      if (boundsEqual(member.bounds, source.bounds) && member.stage === source.stage && member.snapZone === source.snapZone && member.layer === source.layer && member.workspace === source.workspace) {
+      if (boundsEqual(member.bounds, effective.bounds) && member.stage === effective.stage && member.snapZone === effective.snapZone && member.layer === effective.layer && member.workspace === effective.workspace) {
         continue;
       }
       setWindow({
         ...member,
-        bounds: source.bounds,
-        stage: source.stage,
-        snapZone: source.snapZone,
-        restoreBounds: source.restoreBounds,
-        restoreStage: source.restoreStage,
-        layer: source.layer,
-        workspace: source.workspace
+        bounds: effective.bounds,
+        stage: effective.stage,
+        snapZone: effective.snapZone,
+        restoreBounds: effective.restoreBounds,
+        restoreStage: effective.restoreStage,
+        layer: effective.layer,
+        workspace: effective.workspace
       });
     }
+    return effective;
   }
   function dissolveIfOrphaned(groupId) {
     const members = membersOf(groupId);
@@ -320,6 +375,7 @@ function createWindowManager(options = {}) {
     activeTabs = rest;
   }
   function topModalId() {
+    if (modalCount === 0) return null;
     for (let i = order.length - 1; i >= 0; i -= 1) {
       const win = windows[order[i]];
       if (win.layer === "modal" && win.stage !== "minimized" && onActiveWorkspace(win) && isVisibleTab(win)) {
@@ -338,8 +394,13 @@ function createWindowManager(options = {}) {
     });
   }
   function focusTop() {
-    const targets = focusTargets();
-    focusedId = targets.length > 0 ? targets[targets.length - 1] : null;
+    for (let i = order.length - 1; i >= 0; i -= 1) {
+      const win = windows[order[i]];
+      if (win.stage === "minimized" || !onActiveWorkspace(win) || !isVisibleTab(win)) continue;
+      focusedId = win.id;
+      return;
+    }
+    focusedId = null;
   }
   function reconcileFocus() {
     if (focusedId === null) return;
@@ -530,8 +591,8 @@ function createWindowManager(options = {}) {
     const next = build(win);
     if (!next) return false;
     setWindow(next);
-    syncGroup(next);
-    queueEvent(() => emitter.emit("stage", { window: next, previous: win.stage }));
+    const synced = syncGroup(next);
+    queueEvent(() => emitter.emit("stage", { window: synced, previous: win.stage }));
     if (next.groupId !== null) reconcileFocus();
     commit();
     return true;
@@ -663,9 +724,11 @@ function createWindowManager(options = {}) {
     if (boundsEqual(bounds, win.bounds) && !becameNormal) return true;
     const next = becameNormal ? { ...win, stage: "normal", snapZone: null, restoreBounds: null, bounds } : { ...win, bounds };
     setWindow(next);
-    syncGroup(next);
-    if (becameNormal) queueEvent(() => emitter.emit("stage", { window: next, previous: "snapped" }));
-    queueEvent(() => emitter.emit("resize", { window: next }));
+    const synced = syncGroup(next);
+    if (becameNormal) {
+      queueEvent(() => emitter.emit("stage", { window: synced, previous: "snapped" }));
+    }
+    queueEvent(() => emitter.emit("resize", { window: synced }));
     commit();
     return true;
   }
@@ -691,18 +754,18 @@ function createWindowManager(options = {}) {
     const resized = size.width !== next.bounds.width || size.height !== next.bounds.height;
     const finalWin = resized ? { ...next, bounds: { ...next.bounds, ...size } } : next;
     setWindow(finalWin);
-    syncGroup(finalWin);
+    const synced = syncGroup(finalWin);
     if (patch.layer && patch.layer !== win.layer) {
       order = sortByLayer(order);
       queueEvent(() => emitter.emit("order", { order }));
       if (patch.layer === "modal" && topModalId() === id && focusedId !== id) {
         const previous = focusedId;
         focusedId = id;
-        emitFocus(finalWin, previous);
+        emitFocus(synced, previous);
       }
     }
-    queueEvent(() => emitter.emit("update", { window: finalWin }));
-    if (resized) queueEvent(() => emitter.emit("resize", { window: finalWin }));
+    queueEvent(() => emitter.emit("update", { window: synced }));
+    if (resized) queueEvent(() => emitter.emit("resize", { window: synced }));
     commit();
     return true;
   }
@@ -797,9 +860,10 @@ function createWindowManager(options = {}) {
     emitGroup(groupId, null);
     queueEvent(() => emitter.emit("order", { order }));
     const hostVisible = onActiveWorkspace(host) && host.stage !== "minimized";
-    if (!hostVisible) reconcileFocus();
     commit();
     if (hostVisible) focus(host.id);
+    reconcileFocus();
+    commit();
     return groupId;
   }
   function ungroup(id) {
@@ -869,6 +933,7 @@ function createWindowManager(options = {}) {
     return Object.values(windows).filter((win) => win.stage === "minimized" && onActiveWorkspace(win) && isVisibleTab(win)).sort((a, b) => a.openedSeq - b.openedSeq);
   }
   function captureEntry() {
+    windowsShared = true;
     return { windows, order, focusedId, workspace, activeTabs };
   }
   function recordHistory() {
@@ -913,13 +978,13 @@ function createWindowManager(options = {}) {
       if (win.stage === "maximized") {
         const updated = { ...win, bounds: fullBounds() };
         setWindow(updated);
-        syncGroup(updated);
-        queueEvent(() => emitter.emit("resize", { window: updated }));
+        const synced = syncGroup(updated);
+        queueEvent(() => emitter.emit("resize", { window: synced }));
       } else if (win.stage === "snapped" && win.snapZone) {
         const updated = { ...win, bounds: snapBounds(win, win.snapZone) };
         setWindow(updated);
-        syncGroup(updated);
-        queueEvent(() => emitter.emit("resize", { window: updated }));
+        const synced = syncGroup(updated);
+        queueEvent(() => emitter.emit("resize", { window: synced }));
       } else if (win.stage === "normal" && keepInViewport) {
         const bounds = clampToViewport(win.bounds, viewport, minVisible);
         if (!boundsEqual(bounds, win.bounds)) {
@@ -934,6 +999,8 @@ function createWindowManager(options = {}) {
   function applyEntry(entry) {
     windows = entry.windows;
     order = [...entry.order];
+    modalCount = countModals();
+    groupsDirty = true;
     focusedId = entry.focusedId;
     activeTabs = entry.activeTabs;
     const previousWorkspace = workspace;
@@ -1152,8 +1219,11 @@ function createWindowManager(options = {}) {
       if (!seen.has(id)) nextOrder.push(id);
     }
     windows = nextWindows;
+    windowsShared = false;
     order = nextOrder;
     order = sortByLayer(order);
+    modalCount = countModals();
+    groupsDirty = true;
     seq = maxSeq;
     const previousWorkspace = workspace;
     workspace = normalizeWorkspace(data.workspace, 0);
@@ -1262,6 +1332,7 @@ function createWindowManager(options = {}) {
 
 // src/dom/animate.ts
 function prefersReducedMotion(win) {
+  if (typeof win.matchMedia !== "function") return false;
   return win.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 function flipFromTarget(source, target, options = {}) {
@@ -1390,14 +1461,6 @@ function createAnnouncer(wm, container, messages = {}) {
   };
 }
 
-// src/dom/shared.ts
-var INTERACTIVE_SELECTOR = "button, input, select, textarea, a[href], [contenteditable], [data-wm-close], [data-wm-minimize], [data-wm-maximize]";
-function windowOf(element) {
-  const view = element.ownerDocument.defaultView;
-  if (!view) throw new Error("wmkit: desktop element is not attached to a document");
-  return view;
-}
-
 // src/dom/drag.ts
 function createDragStarter(ctx) {
   const { wm, doc, view } = ctx;
@@ -1405,7 +1468,7 @@ function createDragStarter(ctx) {
     const win = wm.get(id);
     if (!win?.draggable || event.button !== 0 || ctx.currentDrag()) return;
     const target = event.target;
-    if (target?.closest(INTERACTIVE_SELECTOR)) return;
+    if (target?.closest(ctx.interactiveSelector)) return;
     event.preventDefault();
     const releaseRect = ctx.trackRect();
     const point = ctx.toLocal(event);
@@ -1760,6 +1823,99 @@ function createResizeHandles(doc, edge, corner) {
   });
 }
 
+// src/dom/shared.ts
+var INTERACTIVE_SELECTOR = "button, input, select, textarea, a[href], [contenteditable], [data-wm-close], [data-wm-minimize], [data-wm-maximize]";
+function windowOf(element) {
+  const view = element.ownerDocument.defaultView;
+  if (!view) throw new Error("wmkit: desktop element is not attached to a document");
+  return view;
+}
+
+// src/dom/stacking.ts
+var UNASSIGNED = Number.NEGATIVE_INFINITY;
+var tails = new Int32Array(0);
+var parents = new Int32Array(0);
+var kept = new Uint8Array(0);
+function reserve(length) {
+  if (tails.length >= length) return;
+  const size = Math.max(length, 64);
+  tails = new Int32Array(size);
+  parents = new Int32Array(size);
+  kept = new Uint8Array(size);
+}
+function markLongestIncreasing(target) {
+  const length = target.length;
+  reserve(length);
+  kept.fill(0, 0, length);
+  let size = 0;
+  for (let i = 0; i < length; i += 1) {
+    const value = target.zAt(i);
+    parents[i] = -1;
+    if (!Number.isFinite(value)) continue;
+    let low = 0;
+    let high = size;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (target.zAt(tails[mid]) < value) low = mid + 1;
+      else high = mid;
+    }
+    if (low > 0) parents[i] = tails[low - 1];
+    tails[low] = i;
+    if (low === size) size += 1;
+  }
+  let cursor = size > 0 ? tails[size - 1] : -1;
+  let count = 0;
+  while (cursor !== -1) {
+    kept[cursor] = 1;
+    count += 1;
+    cursor = parents[cursor];
+  }
+  return count;
+}
+function between(low, high, base, gap) {
+  if (!Number.isFinite(high)) return Number.isFinite(low) ? low + gap : base + gap;
+  if (!Number.isFinite(low)) {
+    const candidate2 = high - gap > base ? high - gap : Math.floor((base + high) / 2);
+    return candidate2 > base && candidate2 < high ? candidate2 : null;
+  }
+  const candidate = Math.floor((low + high) / 2);
+  return candidate > low && candidate < high ? candidate : null;
+}
+function renormalize(target, base, gap) {
+  let writes = 0;
+  for (let i = 0; i < target.length; i += 1) {
+    const z = base + (i + 1) * gap;
+    if (target.zAt(i) === z) continue;
+    target.assign(i, z);
+    writes += 1;
+  }
+  return writes;
+}
+function restack(target, options = {}) {
+  const base = options.base ?? 0;
+  const gap = options.gap ?? 32;
+  const length = target.length;
+  if (length === 0) return 0;
+  const keepCount = markLongestIncreasing(target);
+  if (length - keepCount > length / 3) return renormalize(target, base, gap);
+  let writes = 0;
+  for (let i = 0; i < length; i += 1) {
+    if (kept[i] === 1) continue;
+    const low = i > 0 ? target.zAt(i - 1) : UNASSIGNED;
+    let high = Number.POSITIVE_INFINITY;
+    for (let j = i + 1; j < length; j += 1) {
+      if (kept[j] !== 1) continue;
+      high = target.zAt(j);
+      break;
+    }
+    const z = between(low, high, base, gap);
+    if (z === null) return renormalize(target, base, gap);
+    target.assign(i, z);
+    writes += 1;
+  }
+  return writes;
+}
+
 // src/dom/controller.ts
 var SNAP_SHORTCUTS = {
   ArrowLeft: "left",
@@ -1786,11 +1942,17 @@ function attachDesktop(wm, element, options = {}) {
   const hitEdge = options.hitAreas?.edge ?? (coarsePointer ? 16 : 8);
   const hitCorner = options.hitAreas?.corner ?? (coarsePointer ? 24 : 12);
   const magnetThreshold = options.magnetism === false ? 0 : (typeof options.magnetism === "object" ? options.magnetism.threshold : void 0) ?? (coarsePointer ? 12 : 8);
+  const zIndexBase = options.stacking?.base ?? 0;
+  const zIndexGap = options.stacking?.gap ?? 32;
+  const interactiveSelector = options.interactiveSelector ?? INTERACTIVE_SELECTOR;
+  const animationEnabled = options.animation !== false;
+  const animationOptions = typeof options.animation === "object" ? options.animation : {};
   element.dataset.wmDesktop = "";
   element.tabIndex = -1;
   if (view.getComputedStyle(element).position === "static") {
     element.style.position = "relative";
   }
+  if (options.stacking?.isolate !== false) element.style.isolation = "isolate";
   const registry = /* @__PURE__ */ new Map();
   const cleanup = [];
   let lastOrder = null;
@@ -1868,6 +2030,7 @@ function attachDesktop(wm, element, options = {}) {
     topEdge,
     hitEdge,
     hitCorner,
+    interactiveSelector,
     magnetThreshold,
     groupDwell,
     groupTarget(clientX, clientY, selfId) {
@@ -1904,7 +2067,7 @@ function attachDesktop(wm, element, options = {}) {
     observer.observe(element);
     cleanup.push(() => observer.disconnect());
   }
-  function syncWindow(attached, win, zIndex, activeWorkspace, activeTab) {
+  function syncWindow(attached, win, activeWorkspace, activeTab) {
     const el = attached.element;
     const firstSync = attached.lastState === null;
     if (firstSync) el.style.transition = "none";
@@ -1942,27 +2105,44 @@ function attachDesktop(wm, element, options = {}) {
       attached.lastWorkspace = activeWorkspace;
       attached.lastTab = activeTab;
     }
-    if (attached.lastZ !== zIndex) {
-      el.style.zIndex = String(zIndex + 1);
-      attached.lastZ = zIndex;
-    }
     if (firstSync) {
       void el.offsetWidth;
       el.style.transition = "";
     }
   }
+  const stackRows = [];
+  const stackTarget = {
+    length: 0,
+    zAt: (index) => stackRows[index].lastZ,
+    assign(index, z) {
+      const attached = stackRows[index];
+      attached.lastZ = z;
+      attached.element.style.zIndex = String(z);
+    }
+  };
+  function applyStacking(order) {
+    let length = 0;
+    for (const id of order) {
+      const attached = registry.get(id);
+      if (attached) stackRows[length++] = attached;
+    }
+    stackTarget.length = length;
+    restack(stackTarget, { base: zIndexBase, gap: zIndexGap });
+    stackRows.length = length;
+  }
   function syncAll() {
     const state = wm.getState();
     const orderChanged = state.order !== lastOrder;
-    state.order.forEach((id, index) => {
+    for (const id of state.order) {
       const attached = registry.get(id);
       const win = state.windows[id];
-      if (!attached || !win) return;
+      if (!attached || !win) continue;
       const activeTab = win.groupId === null || state.groups[win.groupId]?.activeId === win.id;
-      if (orderChanged || attached.lastState !== win || attached.lastWorkspace !== state.workspace || attached.lastTab !== activeTab) {
-        syncWindow(attached, win, index, state.workspace, activeTab);
+      if (attached.lastState !== win || attached.lastWorkspace !== state.workspace || attached.lastTab !== activeTab) {
+        syncWindow(attached, win, state.workspace, activeTab);
       }
-    });
+    }
+    if (orderChanged) applyStacking(state.order);
     if (state.focusedId !== lastFocused) {
       if (lastFocused) {
         const prev = registry.get(lastFocused);
@@ -2000,12 +2180,17 @@ function attachDesktop(wm, element, options = {}) {
     wm.on("stage", ({ window: win, previous }) => {
       const attached = registry.get(win.id);
       if (!attached) return;
+      if (!animationEnabled) return;
       if (win.stage === "minimized" && previous !== "minimized") {
         const target = options.minimizeTarget?.(win);
-        if (target) flipToTarget(attached.element, target);
+        if (target) flipToTarget(attached.element, target, animationOptions);
       } else if (previous === "minimized" && win.stage !== "minimized") {
         const target = options.minimizeTarget?.(win);
-        if (target) view.requestAnimationFrame(() => flipFromTarget(attached.element, target));
+        if (target) {
+          view.requestAnimationFrame(
+            () => flipFromTarget(attached.element, target, animationOptions)
+          );
+        }
       }
     })
   );
@@ -2019,7 +2204,7 @@ function attachDesktop(wm, element, options = {}) {
       if (!event.ctrlKey && !event.metaKey) return;
       if (drag) return;
       const target = event.target;
-      if (target?.closest(INTERACTIVE_SELECTOR)) return;
+      if (target?.closest(interactiveSelector)) return;
       if (historyShortcuts && (event.key === "z" || event.key === "Z")) {
         event.preventDefault();
         if (event.shiftKey) wm.redo();
@@ -2061,7 +2246,7 @@ function attachDesktop(wm, element, options = {}) {
       handle: null,
       handles: [],
       lastState: null,
-      lastZ: -1,
+      lastZ: UNASSIGNED,
       lastWorkspace: -1,
       lastTab: true,
       cleanup: []
@@ -2095,7 +2280,7 @@ function attachDesktop(wm, element, options = {}) {
       const current = wm.get(id);
       if (!current) return;
       if (target.closest("[data-wm-close]")) {
-        if (current.closable) wm.close(id);
+        if (current.closable && options.beforeClose?.(current) !== false) wm.close(id);
       } else if (target.closest("[data-wm-minimize]")) {
         if (current.minimizable) wm.minimize(id);
       } else if (target.closest("[data-wm-maximize]")) {
@@ -2111,7 +2296,7 @@ function attachDesktop(wm, element, options = {}) {
       attached.cleanup.push(() => handle.removeEventListener("pointerdown", onHandleDown));
       const onDoubleClick = (event) => {
         const target = event.target;
-        if (target?.closest(INTERACTIVE_SELECTOR)) return;
+        if (target?.closest(interactiveSelector)) return;
         const current = wm.get(id);
         if (current?.maximizable) wm.toggleMaximize(id);
       };
@@ -2143,7 +2328,7 @@ function attachDesktop(wm, element, options = {}) {
     }
     const onWindowKeydown = (event) => {
       const target = event.target;
-      if (target?.closest(INTERACTIVE_SELECTOR)) return;
+      if (target?.closest(interactiveSelector)) return;
       const current = wm.get(id);
       if (!current) return;
       const arrows = {
@@ -2303,5 +2488,5 @@ exports.flipToTarget = flipToTarget;
 exports.magnetize = magnetize;
 exports.prefersReducedMotion = prefersReducedMotion;
 exports.zoneBounds = zoneBounds;
-//# sourceMappingURL=chunk-C2UHNBSA.cjs.map
-//# sourceMappingURL=chunk-C2UHNBSA.cjs.map
+//# sourceMappingURL=chunk-DYZQY3BE.cjs.map
+//# sourceMappingURL=chunk-DYZQY3BE.cjs.map