@owdproject/nuxt 0.0.0-stage → 4.0.0-alpha.3

package/dist/runtime/composables/window/useDesktopWindow.js

@@ -0,0 +1,192 @@
+import { computed } from "vue";
+import { apps } from "../application/state.js";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+import { useDesktopIPC } from "../useDesktopIPC.js";
+import { useDesktopHooks } from "../useDesktopHooks.js";
+const sharedWindowList = computed(() => {
+  const windows = [];
+  for (const app of apps.values()) {
+    if (!app.isRunning && app.openWindowCount.value === 0) {
+      continue;
+    }
+    for (const window2 of app.windows.values()) {
+      windows.push(window2);
+    }
+  }
+  return windows;
+});
+const sharedWindowIndex = computed(() => {
+  const index = /* @__PURE__ */ new Map();
+  for (const win of sharedWindowList.value) {
+    index.set(win.state.id, win);
+  }
+  return index;
+});
+const sharedFocusedWindow = computed(() => {
+  for (const win of sharedWindowList.value) {
+    if (win.state.focused) {
+      return win;
+    }
+  }
+  return void 0;
+});
+export function useDesktopWindow() {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  const activeWorkspaceWindows = computed(() => {
+    const activeWs = desktopWorkspaceStore.active;
+    return sharedWindowList.value.filter(
+      (win) => !win.state.workspace || win.state.workspace === activeWs
+    );
+  });
+  const topMaximizedWindow = computed(() => {
+    if (desktopWorkspaceStore.overview) return void 0;
+    let topWin;
+    let maxZ = -Infinity;
+    for (const win of activeWorkspaceWindows.value) {
+      if (win.state.active !== false && win.state.maximized) {
+        const z = win.position?.z ?? 0;
+        if (z > maxZ) {
+          maxZ = z;
+          topWin = win;
+        }
+      }
+    }
+    return topWin;
+  });
+  function get(windowId) {
+    return sharedWindowIndex.value.get(windowId);
+  }
+  function tileWindows(mode = "horizontal", workspaceId) {
+    const targetWs = workspaceId || desktopWorkspaceStore.active;
+    const visibleWindows = sharedWindowList.value.filter(
+      (win) => (!win.state.workspace || win.state.workspace === targetWs) && win.state.active !== false
+    );
+    if (visibleWindows.length === 0) return 0;
+    const workarea = desktopWorkspaceStore.workarea;
+    const areaX = workarea.width > 0 ? workarea.x : 0;
+    const areaY = workarea.height > 0 ? workarea.y : 48;
+    const areaW = workarea.width > 0 ? workarea.width : window.innerWidth;
+    const areaH = workarea.height > 0 ? workarea.height : window.innerHeight - 48;
+    const gap = 8;
+    const count = visibleWindows.length;
+    const { callHook } = useDesktopHooks();
+    if (count === 1) {
+      const win = visibleWindows[0];
+      win.actions.saveBoundsBeforeLayout();
+      win.actions.setPosition({ x: areaX + gap, y: areaY + gap });
+      win.actions.setSize({ width: areaW - gap * 2, height: areaH - gap * 2 });
+      win.actions.bringToFront();
+      void callHook("window:layout-change", { window: win, layout: "normal" });
+      return 1;
+    }
+    if (mode === "horizontal") {
+      const colW = Math.floor((areaW - gap * (count + 1)) / count);
+      visibleWindows.forEach((win, idx) => {
+        win.actions.saveBoundsBeforeLayout();
+        win.state.maximized = false;
+        const nextLayout = count === 2 ? idx === 0 ? "left-half" : "right-half" : "normal";
+        win.state.layout = nextLayout;
+        win.actions.setPosition({
+          x: areaX + gap + idx * (colW + gap),
+          y: areaY + gap
+        });
+        win.actions.setSize({
+          width: colW,
+          height: areaH - gap * 2
+        });
+        void callHook("window:layout-change", { window: win, layout: nextLayout });
+      });
+    } else if (mode === "vertical") {
+      const rowH = Math.floor((areaH - gap * (count + 1)) / count);
+      visibleWindows.forEach((win, idx) => {
+        win.actions.saveBoundsBeforeLayout();
+        win.state.maximized = false;
+        win.state.layout = "normal";
+        win.actions.setPosition({
+          x: areaX + gap,
+          y: areaY + gap + idx * (rowH + gap)
+        });
+        win.actions.setSize({
+          width: areaW - gap * 2,
+          height: rowH
+        });
+        void callHook("window:layout-change", { window: win, layout: "normal" });
+      });
+    } else {
+      const cols = Math.ceil(Math.sqrt(count));
+      const rows = Math.ceil(count / cols);
+      const cellW = Math.floor((areaW - gap * (cols + 1)) / cols);
+      const cellH = Math.floor((areaH - gap * (rows + 1)) / rows);
+      visibleWindows.forEach((win, idx) => {
+        const col = idx % cols;
+        const row = Math.floor(idx / cols);
+        win.actions.saveBoundsBeforeLayout();
+        win.state.maximized = false;
+        win.state.layout = "normal";
+        win.actions.setPosition({
+          x: areaX + gap + col * (cellW + gap),
+          y: areaY + gap + row * (cellH + gap)
+        });
+        win.actions.setSize({
+          width: cellW,
+          height: cellH
+        });
+        void callHook("window:layout-change", { window: win, layout: "normal" });
+      });
+    }
+    useDesktopIPC().emit(
+      "window:tiled",
+      {
+        mode,
+        count,
+        workspace: targetWs
+      },
+      { source: "display-server", severity: "info" }
+    );
+    return count;
+  }
+  function minimizeAll(workspaceId) {
+    const targetWs = workspaceId || desktopWorkspaceStore.active;
+    for (const win of sharedWindowList.value) {
+      if (!win.state.workspace || win.state.workspace === targetWs) {
+        win.minimize();
+      }
+    }
+  }
+  function restoreAll(workspaceId) {
+    const targetWs = workspaceId || desktopWorkspaceStore.active;
+    for (const win of sharedWindowList.value) {
+      if (!win.state.workspace || win.state.workspace === targetWs) {
+        win.unminimize();
+      }
+    }
+  }
+  return {
+    list: sharedWindowList,
+    index: sharedWindowIndex,
+    activeWorkspaceWindows,
+    focused: sharedFocusedWindow,
+    topMaximizedWindow,
+    get,
+    tileWindows,
+    minimizeAll,
+    restoreAll,
+    close: (windowId) => {
+      const window2 = get(windowId);
+      window2?.application.closeWindow(window2.state.id);
+    },
+    closeAll: (appId) => {
+      if (appId) {
+        const app = apps.get(appId);
+        if (app) {
+          app.closeAllWindows();
+        }
+      } else {
+        for (const app of apps.values()) {
+          app.closeAllWindows();
+        }
+      }
+    }
+  };
+}
+export const useDesktopWindows = useDesktopWindow;

package/dist/runtime/composables/window/useDesktopWindowSnapDrop.d.ts

@@ -0,0 +1,13 @@
+import type { DesktopWorkareaRect, IWindowController } from '../../../types/index.js';
+import type { Ref } from 'vue';
+/**
+ * While dragging a maximizable window, highlight snap zones in the shell work area.
+ */
+export declare function useDesktopWindowSnapDrop(): {
+    snapHint: any;
+    snapHintRect: import("vue").ComputedRef<import("@owdproject/core").WindowBounds | null>;
+    isSnapDragActive: Ref<boolean, boolean>;
+    beginWindowSnapDrag: (windowId: string, workarea: DesktopWorkareaRect, maximizable: boolean) => void;
+    endWindowSnapDrag: (win: IWindowController) => boolean;
+    activeWorkarea: () => DesktopWorkareaRect;
+};

package/dist/runtime/composables/window/useDesktopWindowSnapDrop.js

@@ -0,0 +1,78 @@
+import { computed, ref } from "vue";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+import {
+  detectSnapZone
+} from "../../utils/utilDetectSnapZone.js";
+import { applySnapToWindow, computeSnapRect } from "../../utils/utilWindowLayout.js";
+const snapHint = ref(null);
+const isSnapDragActive = ref(false);
+let snapDraggingWindowId = null;
+let activeWorkarea = { x: 0, y: 0, width: 0, height: 0 };
+function onDocumentPointerMove(e) {
+  updateSnapHintFromPointer(e.clientX, e.clientY);
+}
+function onDocumentMouseMove(e) {
+  updateSnapHintFromPointer(e.clientX, e.clientY);
+}
+function stopSnapPointerTracking() {
+  document.removeEventListener("pointermove", onDocumentPointerMove);
+  document.removeEventListener("mousemove", onDocumentMouseMove);
+}
+function updateSnapHintFromPointer(clientX, clientY) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  if (!isSnapDragActive.value || desktopWorkspaceStore.overview) {
+    snapHint.value = null;
+    return;
+  }
+  const deferSide = desktopWorkspaceStore.list.length > 1 && !desktopWorkspaceStore.overview;
+  snapHint.value = detectSnapZone(clientX, clientY, activeWorkarea, {
+    deferSideSnapForWorkspaceEdge: deferSide
+  });
+}
+export function useDesktopWindowSnapDrop() {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  function beginWindowSnapDrag(windowId, workarea, maximizable) {
+    if (desktopWorkspaceStore.overview) return;
+    if (!maximizable) return;
+    if (workarea.width <= 0 || workarea.height <= 0) return;
+    snapDraggingWindowId = windowId;
+    isSnapDragActive.value = true;
+    activeWorkarea = { ...workarea };
+    snapHint.value = null;
+    document.addEventListener("pointermove", onDocumentPointerMove, {
+      passive: true
+    });
+    document.addEventListener("mousemove", onDocumentMouseMove, {
+      passive: true
+    });
+  }
+  function commitSnapDrop(win) {
+    const zone = snapHint.value;
+    if (!zone || !snapDraggingWindowId) return false;
+    return applySnapToWindow(win, zone, activeWorkarea);
+  }
+  function endWindowSnapDrag(win) {
+    stopSnapPointerTracking();
+    let snapped = false;
+    if (isSnapDragActive.value && snapHint.value) {
+      snapped = commitSnapDrop(win);
+    }
+    isSnapDragActive.value = false;
+    snapDraggingWindowId = null;
+    snapHint.value = null;
+    return snapped;
+  }
+  const snapHintRect = computed(() => {
+    const zone = snapHint.value;
+    if (!zone || activeWorkarea.width <= 0) return null;
+    return computeSnapRect(zone, activeWorkarea);
+  });
+  return {
+    snapHint,
+    snapHintRect,
+    isSnapDragActive,
+    beginWindowSnapDrag,
+    endWindowSnapDrag,
+    activeWorkarea: () => activeWorkarea
+  };
+}

package/dist/runtime/composables/workspace/useDesktopWorkspaceEdgeDrop.d.ts

@@ -0,0 +1,25 @@
+import type { IWindowController } from '../../../types/index.js';
+declare function adjacentWorkspaceId(side: 'left' | 'right'): string | null;
+/**
+ * While dragging a window (normal desktop, not overview), highlight left/right
+ * screen edges when an adjacent workspace exists so the user can drop there.
+ */
+export declare function useDesktopWorkspaceEdgeDrop(): {
+    edgeHint: import("vue").Ref<"left" | "right" | null, "left" | "right" | null>;
+    edgeTargetDesktopIndex: import("vue").ComputedRef<number | null>;
+    isWindowDragActive: import("vue").Ref<boolean, boolean>;
+    beginWindowDrag: (windowId: string) => void;
+    endWindowDrag: (windowInstance?: IWindowController) => boolean;
+    adjacentWorkspaceId: typeof adjacentWorkspaceId;
+};
+/**
+ * Wire {@link useDesktopWorkspaceEdgeDrop} to DesktopWindow drag events (theme Window wrapper).
+ */
+export declare function useDesktopWorkspaceEdgeDropWindowHandlers(getWindow: () => IWindowController | undefined): {
+    onDragStart: () => void;
+    onDragEnd: (data: {
+        left: number;
+        top: number;
+    }) => void;
+};
+export {};

package/dist/runtime/composables/workspace/useDesktopWorkspaceEdgeDrop.js

@@ -0,0 +1,119 @@
+import { computed, ref } from "vue";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+import { WORKSPACE_EDGE_DROP_PX } from "../../constants/shellLayout.js";
+const edgeHint = ref(null);
+const isWindowDragActive = ref(false);
+let draggingWindowId = null;
+function adjacentWorkspaceId(side) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  if (desktopWorkspaceStore.overview) return null;
+  const list = desktopWorkspaceStore.list;
+  if (list.length < 2) return null;
+  const index = desktopWorkspaceStore.workspaceActiveIndex;
+  if (index < 0) return null;
+  if (side === "left" && index > 0) {
+    return list[index - 1] ?? null;
+  }
+  if (side === "right" && index < list.length - 1) {
+    return list[index + 1] ?? null;
+  }
+  return null;
+}
+function updateEdgeHintFromClientX(clientX) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  if (!isWindowDragActive.value || desktopWorkspaceStore.overview) {
+    edgeHint.value = null;
+    return;
+  }
+  const viewportWidth = typeof globalThis !== "undefined" ? globalThis.innerWidth : 0;
+  if (clientX <= WORKSPACE_EDGE_DROP_PX && adjacentWorkspaceId("left")) {
+    edgeHint.value = "left";
+    return;
+  }
+  if (clientX >= viewportWidth - WORKSPACE_EDGE_DROP_PX && adjacentWorkspaceId("right")) {
+    edgeHint.value = "right";
+    return;
+  }
+  edgeHint.value = null;
+}
+function onDocumentPointerMove(e) {
+  updateEdgeHintFromClientX(e.clientX);
+}
+function stopPointerTracking() {
+  document.removeEventListener("pointermove", onDocumentPointerMove);
+}
+export function useDesktopWorkspaceEdgeDrop() {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  function beginWindowDrag(windowId) {
+    if (desktopWorkspaceStore.overview) return;
+    if (desktopWorkspaceStore.list.length < 2) return;
+    draggingWindowId = windowId;
+    isWindowDragActive.value = true;
+    edgeHint.value = null;
+    document.addEventListener("pointermove", onDocumentPointerMove, {
+      passive: true
+    });
+  }
+  function commitEdgeDrop(windowInstance) {
+    const side = edgeHint.value;
+    if (!side || !draggingWindowId) return false;
+    const targetWorkspaceId = adjacentWorkspaceId(side);
+    if (!targetWorkspaceId) return false;
+    windowInstance.actions.setWorkspace(targetWorkspaceId);
+    desktopWorkspaceStore.setWorkspace(targetWorkspaceId);
+    const inset = WORKSPACE_EDGE_DROP_PX + 24;
+    const pos = windowInstance.position;
+    if (pos && typeof pos.y === "number") {
+      const viewportWidth = typeof globalThis !== "undefined" ? globalThis.innerWidth : 1920;
+      const rawWidth = windowInstance.size?.width ?? 400;
+      const width = typeof rawWidth === "number" ? rawWidth : Number.parseFloat(String(rawWidth)) || 400;
+      const x = side === "left" ? inset : Math.max(inset, viewportWidth - width - inset);
+      windowInstance.actions.setPosition({ x, y: pos.y });
+    }
+    return true;
+  }
+  function endWindowDrag(windowInstance) {
+    stopPointerTracking();
+    let moved = false;
+    if (windowInstance && edgeHint.value) {
+      moved = commitEdgeDrop(windowInstance);
+    }
+    isWindowDragActive.value = false;
+    draggingWindowId = null;
+    edgeHint.value = null;
+    return moved;
+  }
+  const edgeTargetDesktopIndex = computed(() => {
+    const side = edgeHint.value;
+    if (!side) return null;
+    const targetId = adjacentWorkspaceId(side);
+    if (!targetId) return null;
+    const index = desktopWorkspaceStore.list.indexOf(targetId);
+    return index >= 0 ? index + 1 : null;
+  });
+  return {
+    edgeHint,
+    edgeTargetDesktopIndex,
+    isWindowDragActive,
+    beginWindowDrag,
+    endWindowDrag,
+    adjacentWorkspaceId
+  };
+}
+export function useDesktopWorkspaceEdgeDropWindowHandlers(getWindow) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  const { beginWindowDrag, endWindowDrag } = useDesktopWorkspaceEdgeDrop();
+  function onDragStart() {
+    const windowInstance = getWindow();
+    if (!windowInstance?.state?.id || desktopWorkspaceStore.overview) return;
+    beginWindowDrag(windowInstance.state.id);
+  }
+  function onDragEnd(data) {
+    const windowInstance = getWindow();
+    const moved = Boolean(windowInstance) && !desktopWorkspaceStore.overview && endWindowDrag(windowInstance);
+    if (!moved && windowInstance) {
+      windowInstance.actions.setPosition({ x: data.left, y: data.top });
+    }
+  }
+  return { onDragStart, onDragEnd };
+}

package/dist/runtime/composables/workspace/useDesktopWorkspaceManager.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Keyboard + HTML5 drop handlers for workspace management (move windows between desktops).
+ */
+export declare function useDesktopWorkspaceManager(): {
+    onWorkspaceDragOver: (e: DragEvent) => void;
+    onWorkspaceDrop: (e: DragEvent, workspaceId: string) => void;
+    removeWorkspace: (workspaceId: string) => boolean;
+};

package/dist/runtime/composables/workspace/useDesktopWorkspaceManager.js

@@ -0,0 +1,46 @@
+import { useEventListener } from "@vueuse/core";
+import { useDesktopWindow } from "../window/useDesktopWindow.js";
+import { apps } from "../application/state.js";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+import { collectWindowsOnWorkspace } from "../../utils/utilWorkspaceWindows.js";
+export function useDesktopWorkspaceManager() {
+  const desktopWindow = useDesktopWindow();
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  useEventListener(window, "keydown", (e) => {
+    if (e.key !== "Escape") return;
+    if (!desktopWorkspaceStore.overview) return;
+    desktopWorkspaceStore.setOverview(false);
+  });
+  function onWorkspaceDragOver(e) {
+    if (!desktopWorkspaceStore.overview) return;
+    e.preventDefault();
+  }
+  function onWorkspaceDrop(e, workspaceId) {
+    e.preventDefault();
+    if (!desktopWorkspaceStore.overview) return;
+    const raw = e.dataTransfer?.getData("text/plain") || e.dataTransfer?.getData("text") || "";
+    if (!raw) return;
+    const windowInstance = desktopWindow.get(raw);
+    windowInstance?.actions.setWorkspace(workspaceId);
+  }
+  function removeWorkspace(workspaceId) {
+    if (desktopWorkspaceStore.list.length <= 2) return false;
+    const fallbackId = desktopWorkspaceStore.resolveWorkspaceFallback(workspaceId);
+    if (!fallbackId) return false;
+    const activeId = desktopWorkspaceStore.active;
+    const windows = collectWindowsOnWorkspace(
+      apps.values(),
+      workspaceId,
+      activeId
+    );
+    for (const windowInstance of windows) {
+      windowInstance.actions.setWorkspace(fallbackId);
+    }
+    return desktopWorkspaceStore.removeWorkspace(workspaceId);
+  }
+  return {
+    onWorkspaceDragOver,
+    onWorkspaceDrop,
+    removeWorkspace
+  };
+}

package/dist/runtime/composables/workspace/useDesktopWorkspaceOverviewCapture.d.ts

@@ -0,0 +1,20 @@
+export type WorkspaceRootResolver = (workspaceId: string) => HTMLElement | null | undefined;
+export type UseWorkspaceOverviewCaptureOptions = {
+    /** Delay before capturing after overview opens (ms). Default 150. */
+    debounceMs?: number;
+    /** JPEG quality for thumbnail data URLs (0–1). Default 0.7. */
+    jpegQuality?: number;
+    /** Passed through to html2canvas. */
+    captureOptions?: Record<string, unknown>;
+};
+/**
+ * Captures workspace desktop roots as JPEG data URLs while workspace overview is open.
+ * Themes supply a resolver that maps each workspace id to its DOM root (e.g. a layer wrapping
+ * {@link DesktopApplicationRender} with `workspace-filter`).
+ */
+export declare function useDesktopWorkspaceOverviewCapture(resolveWorkspaceRoot: WorkspaceRootResolver, options?: UseWorkspaceOverviewCaptureOptions): {
+    thumbnails: import("vue").ShallowRef<Map<string, string>, Map<string, string>>;
+    isCapturing: import("vue").Ref<boolean, boolean>;
+    refreshThumbnails: () => Promise<void>;
+    thumbnailFor: (workspaceId: string) => string | undefined;
+};

package/dist/runtime/composables/workspace/useDesktopWorkspaceOverviewCapture.js

@@ -0,0 +1,60 @@
+import { useDebounceFn } from "@vueuse/core";
+import { nextTick, ref, shallowRef, watch } from "vue";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+import { captureElementToCanvas } from "../../utils/utilCaptureElementToCanvas.js";
+export function useDesktopWorkspaceOverviewCapture(resolveWorkspaceRoot, options = {}) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  const thumbnails = shallowRef(/* @__PURE__ */ new Map());
+  const isCapturing = ref(false);
+  const debounceMs = options.debounceMs ?? 150;
+  const jpegQuality = options.jpegQuality ?? 0.7;
+  async function captureWorkspace(workspaceId) {
+    const element = resolveWorkspaceRoot(workspaceId);
+    const canvas = await captureElementToCanvas(element, options.captureOptions);
+    if (!canvas) return null;
+    return canvas.toDataURL("image/jpeg", jpegQuality);
+  }
+  async function refreshThumbnails() {
+    if (!desktopWorkspaceStore.overview) return;
+    isCapturing.value = true;
+    const next = /* @__PURE__ */ new Map();
+    try {
+      await nextTick();
+      const ids = [...desktopWorkspaceStore.list];
+      await Promise.all(
+        ids.map(async (id) => {
+          const dataUrl = await captureWorkspace(id);
+          if (dataUrl) next.set(id, dataUrl);
+        })
+      );
+      thumbnails.value = next;
+    } finally {
+      isCapturing.value = false;
+    }
+  }
+  const scheduleRefresh = useDebounceFn(() => {
+    void refreshThumbnails();
+  }, debounceMs);
+  watch(
+    () => desktopWorkspaceStore.overview,
+    (open) => {
+      if (open) scheduleRefresh();
+      else thumbnails.value = /* @__PURE__ */ new Map();
+    }
+  );
+  watch(
+    () => desktopWorkspaceStore.list.join("\0"),
+    () => {
+      if (desktopWorkspaceStore.overview) scheduleRefresh();
+    }
+  );
+  function thumbnailFor(workspaceId) {
+    return thumbnails.value.get(workspaceId);
+  }
+  return {
+    thumbnails,
+    isCapturing,
+    refreshThumbnails,
+    thumbnailFor
+  };
+}

package/dist/runtime/composables/workspace/useDesktopWorkspaceOverviewLiveScale.d.ts

@@ -0,0 +1,31 @@
+import type { CSSProperties, Ref } from 'vue';
+export type WorkspaceStageSize = {
+    width: number;
+    height: number;
+};
+export type WorkspaceOverviewLiveScaleOptions = {
+    /** Upper bound for scale (default 1). */
+    maxScale?: number;
+};
+export type WorkspaceOverviewInnerStyleOptions = WorkspaceOverviewLiveScaleOptions & {
+    transformOrigin?: string;
+};
+/**
+ * Fit factor to show a 1:1 shell stage inside a panel viewport without clipping.
+ */
+export declare function computeScaleToFit(panelWidth: number, panelHeight: number, stageWidth: number, stageHeight: number, options?: WorkspaceOverviewLiveScaleOptions): number;
+/**
+ * Live DOM workspace overview: measure shell stage, scale desktop roots to fit cards.
+ */
+export declare function useDesktopWorkspaceOverviewLiveScale(shellStageRef: Ref<HTMLElement | null | undefined>): {
+    stageSize: Readonly<Ref<{
+        readonly width: number;
+        readonly height: number;
+    }, {
+        readonly width: number;
+        readonly height: number;
+    }>>;
+    scaleToFit: (panelEl: HTMLElement | null | undefined, options?: WorkspaceOverviewLiveScaleOptions) => number;
+    innerOverviewStyle: (panelEl: HTMLElement | null | undefined, options?: WorkspaceOverviewInnerStyleOptions) => CSSProperties | undefined;
+    refreshStageSize: () => void;
+};