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

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

@@ -0,0 +1,92 @@
+import {
+  nextTick,
+  onScopeDispose,
+  readonly,
+  shallowRef,
+  watch
+} from "vue";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+export function computeScaleToFit(panelWidth, panelHeight, stageWidth, stageHeight, options) {
+  if (panelWidth <= 0 || panelHeight <= 0 || stageWidth <= 0 || stageHeight <= 0) {
+    return 1;
+  }
+  const scale = Math.min(panelWidth / stageWidth, panelHeight / stageHeight);
+  const maxScale = options?.maxScale ?? 1;
+  return Math.min(scale, maxScale);
+}
+export function useDesktopWorkspaceOverviewLiveScale(shellStageRef) {
+  const desktopWorkspaceStore = useDesktopWorkspaceStore();
+  const stageSize = shallowRef({ width: 0, height: 0 });
+  let resizeObserver = null;
+  function readStageSize() {
+    const el = shellStageRef.value;
+    if (!el) {
+      stageSize.value = { width: 0, height: 0 };
+      return;
+    }
+    stageSize.value = {
+      width: el.clientWidth,
+      height: el.clientHeight
+    };
+  }
+  function stopObserving() {
+    resizeObserver?.disconnect();
+    resizeObserver = null;
+  }
+  function startObserving() {
+    stopObserving();
+    const el = shellStageRef.value;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    readStageSize();
+    resizeObserver = new ResizeObserver(() => readStageSize());
+    resizeObserver.observe(el);
+  }
+  watch(
+    () => desktopWorkspaceStore.overview,
+    (open) => {
+      if (open) {
+        void nextTick(() => startObserving());
+      } else {
+        stopObserving();
+        stageSize.value = { width: 0, height: 0 };
+      }
+    }
+  );
+  watch(shellStageRef, (el) => {
+    if (desktopWorkspaceStore.overview && el) {
+      void nextTick(() => startObserving());
+    }
+  });
+  onScopeDispose(stopObserving);
+  function scaleToFit(panelEl, options) {
+    if (!panelEl) return 1;
+    const { width: stageWidth, height: stageHeight } = stageSize.value;
+    if (stageWidth <= 0 || stageHeight <= 0) return 1;
+    return computeScaleToFit(
+      panelEl.clientWidth,
+      panelEl.clientHeight,
+      stageWidth,
+      stageHeight,
+      options
+    );
+  }
+  function innerOverviewStyle(panelEl, options) {
+    if (!desktopWorkspaceStore.overview) return void 0;
+    const { width: stageWidth, height: stageHeight } = stageSize.value;
+    if (stageWidth <= 0 || stageHeight <= 0) return void 0;
+    const scale = scaleToFit(panelEl, options);
+    const transformOrigin = options?.transformOrigin ?? "top left";
+    return {
+      width: `${stageWidth}px`,
+      height: `${stageHeight}px`,
+      transform: `scale(${scale})`,
+      transformOrigin
+    };
+  }
+  return {
+    stageSize: readonly(stageSize),
+    scaleToFit,
+    innerOverviewStyle,
+    refreshStageSize: readStageSize
+  };
+}

package/dist/runtime/constants/desktopShellKeys.d.ts

@@ -0,0 +1,5 @@
+import type { InjectionKey } from 'vue';
+import type { DesktopDialogProvider } from '../dialogs/desktopDialogProvider.js';
+export type DesktopToggleWindowMaximizeFn = (win: IWindowController | undefined) => boolean;
+export declare const DESKTOP_DIALOG_PROVIDER_KEY: InjectionKey<DesktopDialogProvider>;
+export declare const DESKTOP_TOGGLE_WINDOW_MAXIMIZE_KEY: InjectionKey<DesktopToggleWindowMaximizeFn>;

package/dist/runtime/constants/desktopShellKeys.js

@@ -0,0 +1,2 @@
+export const DESKTOP_DIALOG_PROVIDER_KEY = Symbol("desktop-dialog-provider");
+export const DESKTOP_TOGGLE_WINDOW_MAXIMIZE_KEY = Symbol("desktop-toggle-window-maximize");

package/dist/runtime/constants/shellLayout.d.ts

@@ -0,0 +1,4 @@
+/** Viewport band (px) where a window drag targets the adjacent workspace. */
+export declare const WORKSPACE_EDGE_DROP_PX = 72;
+/** Viewport band (px) where a window drag targets a snap zone. */
+export declare const WINDOW_SNAP_EDGE_PX = 14;

package/dist/runtime/constants/shellLayout.js

@@ -0,0 +1,2 @@
+export const WORKSPACE_EDGE_DROP_PX = 72;
+export const WINDOW_SNAP_EDGE_PX = 14;

package/dist/runtime/dialogs/desktopDialogProvider.d.ts

@@ -0,0 +1,6 @@
+export interface DesktopDialogProvider {
+    alert(message: string, title?: string): Promise<void>;
+    confirm(message: string, title?: string): Promise<boolean>;
+    prompt(message: string, defaultValue?: string, title?: string): Promise<string | null>;
+}
+export declare function createBrowserFallbackDialogProvider(): DesktopDialogProvider;

package/dist/runtime/dialogs/desktopDialogProvider.js

@@ -0,0 +1,12 @@
+export function createBrowserFallbackDialogProvider() {
+  return {
+    async alert(_message) {
+    },
+    async confirm(_message) {
+      return true;
+    },
+    async prompt(_message, defaultValue = "") {
+      return defaultValue;
+    }
+  };
+}

package/dist/runtime/internal/controllers/ApplicationController.d.ts

@@ -0,0 +1,44 @@
+import { type ApplicationConfig, type CommandOutput, type WindowStoredState } from '@owdproject/core';
+import type { IApplicationController, IWindowController } from '../../../types/index.js';
+import { useApplicationWindowsStore } from '../../stores/storeApplicationWindows.js';
+export declare class ApplicationController implements IApplicationController {
+    readonly id: string;
+    readonly config: ApplicationConfig;
+    readonly windows: import("vue").ShallowReactive<Map<string, IWindowController>>;
+    readonly openWindowCount: import("vue").ShallowRef<number, number>;
+    storeWindows: ReturnType<typeof useApplicationWindowsStore> | undefined;
+    storeMeta: any;
+    private readonly _pid;
+    private readonly _startedAt;
+    private readonly _stateValue;
+    private readonly _isRunning;
+    private readonly _isSuspended;
+    private appActor;
+    constructor(id: string, config: ApplicationConfig);
+    get windowsOpened(): Map<string, IWindowController>;
+    getFirstWindowByModel(model: string): IWindowController | undefined;
+    get pid(): number | null;
+    get startedAt(): number | null;
+    get stateValue(): string;
+    get isRunning(): boolean;
+    get isSuspended(): boolean;
+    get isInitializing(): boolean;
+    get isReady(): boolean;
+    initApplication(): Promise<void>;
+    /**
+     * Reopen the windows persisted in this application's window store. Returns
+     * `true` when at least one window was restored. No-op without a persistence
+     * adapter (the window store is then always empty at boot).
+     */
+    restoreApplication(): Promise<boolean>;
+    private restoreWindows;
+    focusWindow(targetWin: IWindowController): void;
+    openWindow(model: string, storedState?: WindowStoredState, meta?: Record<string, any>): IWindowController | undefined;
+    closeWindow(windowId: string): void;
+    closeAllWindows(): void;
+    setRunning(value: boolean): void;
+    suspend(): void;
+    resume(): void;
+    sendSignal(signal?: 'SIGTERM' | 'SIGKILL' | 'SIGSTOP' | 'SIGCONT'): void;
+    execCommand(command: string): Promise<CommandOutput | void>;
+}

package/dist/runtime/internal/controllers/ApplicationController.js

@@ -0,0 +1,470 @@
+import { markRaw, reactive, shallowRef, shallowReactive } from "vue";
+import { createActor } from "xstate";
+import { nanoid } from "nanoid";
+import {
+  applicationMachine,
+  computeSnapRect
+} from "@owdproject/core";
+import { WindowController } from "./WindowController.js";
+import { apps } from "../../composables/application/state.js";
+import { useDesktopCommands } from "../../composables/useDesktopCommands.js";
+import { useDesktopDefaultApps } from "../../composables/useDesktopDefaultApps.js";
+import { useDesktopHooks } from "../../composables/useDesktopHooks.js";
+import { useDesktopIPC } from "../../composables/useDesktopIPC.js";
+import { useDesktopStore } from "../../stores/storeDesktop.js";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace.js";
+import { useApplicationWindowsStore } from "../../stores/storeApplicationWindows.js";
+import { useApplicationMetaStore } from "../../stores/storeApplicationMeta.js";
+let globalPidCounter = 1e3;
+function formatAppSnapshotValue(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length > 0) {
+      const [k, v] = entries[0];
+      return `${k}.${formatAppSnapshotValue(v)}`;
+    }
+  }
+  return "idle";
+}
+export class ApplicationController {
+  id;
+  config;
+  windows = shallowReactive(/* @__PURE__ */ new Map());
+  openWindowCount = shallowRef(0);
+  storeWindows;
+  storeMeta;
+  _pid = shallowRef(null);
+  _startedAt = shallowRef(null);
+  _stateValue = shallowRef("idle");
+  _isRunning = shallowRef(false);
+  _isSuspended = shallowRef(false);
+  appActor;
+  constructor(id, config) {
+    this.id = id;
+    this.config = config;
+    this.appActor = createActor(applicationMachine, {
+      input: {
+        id,
+        config
+      }
+    });
+    this.appActor.subscribe((snapshot) => {
+      const stateStr = formatAppSnapshotValue(snapshot.value);
+      const prevRunning = this._isRunning.value;
+      const nextRunning = snapshot.matches("running");
+      const nextSuspended = snapshot.matches({ running: "suspended" });
+      this._stateValue.value = stateStr;
+      this._isRunning.value = nextRunning;
+      this._isSuspended.value = nextSuspended;
+      if (nextRunning && !prevRunning) {
+        if (!this._pid.value) {
+          globalPidCounter += 1;
+          this._pid.value = globalPidCounter;
+          this._startedAt.value = Date.now();
+        }
+        void useDesktopHooks().callHook("app:launched", {
+          app: this,
+          pid: this._pid.value
+        });
+        useDesktopIPC().emit(
+          "process:launched",
+          { id: this.id, title: this.config.title, pid: this._pid.value },
+          { source: "kernel", severity: "info" }
+        );
+      }
+      if (snapshot.matches("terminating")) {
+        const oldPid = this._pid.value;
+        this._pid.value = null;
+        this._startedAt.value = null;
+        this._isRunning.value = false;
+        this._isSuspended.value = false;
+        try {
+          void this.config.onClose?.(this);
+        } catch {
+        }
+        this.appActor.send({ type: "TERMINATED" });
+        void useDesktopHooks().callHook("app:terminated", {
+          id: this.id,
+          title: this.config.title,
+          pid: oldPid
+        });
+        useDesktopIPC().emit(
+          "process:terminated",
+          { id: this.id, title: this.config.title, pid: oldPid },
+          { source: "kernel", severity: "warn" }
+        );
+      }
+    });
+    this.appActor.start();
+  }
+  get windowsOpened() {
+    return this.windows;
+  }
+  getFirstWindowByModel(model) {
+    for (const window2 of this.windows.values()) {
+      if (window2.model === model) return window2;
+    }
+    return void 0;
+  }
+  get pid() {
+    return this._pid.value;
+  }
+  get startedAt() {
+    return this._startedAt.value;
+  }
+  get stateValue() {
+    return this._stateValue.value;
+  }
+  get isRunning() {
+    return this._isRunning.value;
+  }
+  get isSuspended() {
+    return this._isSuspended.value;
+  }
+  get isInitializing() {
+    return this._stateValue.value === "initializing";
+  }
+  get isReady() {
+    return this._stateValue.value === "ready";
+  }
+  async initApplication() {
+    this.appActor.send({ type: "LAUNCH" });
+    try {
+      this.storeWindows = useApplicationWindowsStore(this.id);
+      const metaFactory = useApplicationMetaStore(this.id);
+      this.storeMeta = metaFactory();
+      const commandsService = useDesktopCommands();
+      if (this.config.commands) {
+        for (const cmdName of Object.keys(this.config.commands)) {
+          const termMeta = this.config.terminal?.[cmdName];
+          commandsService.register({
+            name: cmdName,
+            applicationId: this.id,
+            description: termMeta?.description ?? this.config.description,
+            usage: termMeta?.usage ?? cmdName,
+            args: termMeta?.args,
+            options: termMeta?.options
+          });
+        }
+      }
+      if (this.config.provides) {
+        const defaultApps = useDesktopDefaultApps();
+        defaultApps.setDefaultApp(
+          this.config.provides.name,
+          this,
+          this.config.provides.entry
+        );
+      }
+      const storeWindows = this.storeWindows;
+      if (storeWindows?.$persistedState) {
+        await storeWindows.$persistedState.isReady();
+      }
+      const storeMeta = this.storeMeta;
+      if (storeMeta?.$persistedState) {
+        await storeMeta.$persistedState.isReady();
+      }
+      await this.restoreApplication();
+      this.appActor.send({ type: "INITIALIZED" });
+      await this.config.onReady?.(this);
+    } catch (err) {
+      this.appActor.send({ type: "INIT_FAILED" });
+      console.error(`[@owdproject/nuxt] Failed to init app "${this.id}":`, err);
+    }
+  }
+  /**
+   * Reopen the windows persisted in this application's window store. Returns
+   * `true` when at least one window was restored. No-op without a persistence
+   * adapter (the window store is then always empty at boot).
+   */
+  async restoreApplication() {
+    if (typeof this.config.onRestore === "function") {
+      await this.config.onRestore(this);
+    }
+    const windows = this.storeWindows?.windows;
+    if (!windows || Object.keys(windows).length === 0) {
+      return false;
+    }
+    this.restoreWindows();
+    return true;
+  }
+  restoreWindows() {
+    const windows = this.storeWindows?.windows;
+    if (!windows) return;
+    for (const windowId of Object.keys(windows)) {
+      if (this.windows.has(windowId)) continue;
+      const storedState = windows[windowId];
+      if (storedState?.model) {
+        this.openWindow(storedState.model, storedState);
+      }
+    }
+  }
+  focusWindow(targetWin) {
+    const desktopStore = useDesktopStore();
+    let previousFocused;
+    for (const app of apps.values()) {
+      for (const win of app.windows.values()) {
+        if (win.state.id !== targetWin.state.id && win.state.focused) {
+          previousFocused = win;
+          win.setFocus(false);
+          void useDesktopHooks().callHook("window:blurred", { window: win });
+        }
+      }
+    }
+    const nextZ = desktopStore.incrementPositionZ();
+    if (!targetWin.state.position) {
+      targetWin.state.position = { x: 100, y: 80, z: nextZ };
+    } else {
+      targetWin.state.position.z = nextZ;
+    }
+    targetWin.setFocus(true);
+    void useDesktopHooks().callHook("window:focused", {
+      window: targetWin,
+      previousWindow: previousFocused
+    });
+  }
+  openWindow(model, storedState, meta) {
+    const modelConfig = this.config.windows?.[model];
+    if (!modelConfig) {
+      console.warn(
+        `[@owdproject/nuxt] Window model "${model}" is not defined in app "${this.id}".`
+      );
+      return void 0;
+    }
+    if (this.config.singleton && this.windows.size > 0) {
+      const existing = Array.from(this.windows.values()).find((w) => w.model === model) ?? Array.from(this.windows.values())[0];
+      if (meta && existing.meta && typeof existing.meta === "object") {
+        Object.assign(existing.meta, meta);
+      }
+      const workspaceStore2 = useDesktopWorkspaceStore();
+      if (existing.state.workspace && existing.state.workspace !== workspaceStore2.active) {
+        workspaceStore2.setWorkspace(existing.state.workspace);
+      }
+      existing.actions.setActive(true);
+      existing.actions.bringToFront();
+      return existing;
+    }
+    const openCtx = {
+      app: this,
+      model,
+      config: { ...modelConfig },
+      meta,
+      cancel: false
+    };
+    void useDesktopHooks().callHook("window:before-open", openCtx);
+    if (openCtx.cancel) {
+      return void 0;
+    }
+    const desktopStore = useDesktopStore();
+    const workspaceStore = useDesktopWorkspaceStore();
+    const cascadeIndex = this.windows.size;
+    const cascadeOffset = cascadeIndex * 28;
+    const baseX = openCtx.config.position?.x ?? 120;
+    const baseY = openCtx.config.position?.y ?? 90;
+    const windowId = storedState?.state?.id || `${this.id}-${model}-${nanoid(6)}`;
+    const resolvedStoredState = storedState ?? reactive({
+      model,
+      meta: reactive({ ...openCtx.meta ?? {} }),
+      state: {
+        id: windowId,
+        createdAt: Date.now(),
+        category: openCtx.config.category ?? this.config.category,
+        workspace: workspaceStore.active || "workspace-1",
+        position: {
+          x: baseX + cascadeOffset,
+          y: baseY + cascadeOffset,
+          z: desktopStore.incrementPositionZ()
+        },
+        size: {
+          width: openCtx.config.size?.width ?? 520,
+          height: openCtx.config.size?.height ?? 380,
+          minWidth: openCtx.config.size?.minWidth,
+          minHeight: openCtx.config.size?.minHeight,
+          maxWidth: openCtx.config.size?.maxWidth,
+          maxHeight: openCtx.config.size?.maxHeight
+        },
+        focused: true,
+        active: true,
+        maximized: Boolean(openCtx.config.maximized),
+        minimizable: openCtx.config.minimizable !== false,
+        maximizable: openCtx.config.maximizable !== false,
+        destroyable: openCtx.config.destroyable !== false,
+        draggable: openCtx.config.draggable !== false,
+        resizable: openCtx.config.resizable !== false,
+        layout: openCtx.config.maximized ? "maximize" : "normal"
+      }
+    });
+    const controller = new WindowController(
+      this,
+      model,
+      openCtx.config,
+      resolvedStoredState,
+      {
+        getWorkarea: () => workspaceStore.workarea
+      }
+    );
+    const origSetLayout = controller.actions.setLayout;
+    const enhancedActions = {
+      ...controller.actions,
+      setLayout: (layout) => {
+        const ok = origSetLayout(layout);
+        if (ok && layout !== "normal" && layout !== "maximize") {
+          const workarea = workspaceStore.workarea;
+          const fallbackWorkarea = workarea.width > 0 && workarea.height > 0 ? workarea : {
+            x: 0,
+            y: 48,
+            width: typeof window !== "undefined" ? window.innerWidth : 1280,
+            height: typeof window !== "undefined" ? window.innerHeight - 48 : 752
+          };
+          const rect = computeSnapRect(layout, fallbackWorkarea);
+          controller.actions.setPosition({ x: rect.x, y: rect.y });
+          controller.actions.setSize({ width: rect.width, height: rect.height });
+        }
+        if (ok) {
+          void useDesktopHooks().callHook("window:layout-change", {
+            window: controller,
+            layout
+          });
+          useDesktopIPC().emit(
+            "window:layout-change",
+            { windowId: controller.state.id, title: controller.title, layout },
+            { source: this.id, severity: "info" }
+          );
+        }
+        return ok;
+      }
+    };
+    controller.actions = Object.freeze(enhancedActions);
+    const rawWindow = markRaw(controller);
+    this.windows.set(windowId, rawWindow);
+    this.openWindowCount.value = this.windows.size;
+    this.storeWindows?.setWindowState(windowId, resolvedStoredState);
+    this.appActor.send({ type: "OPEN_WINDOW" });
+    this.focusWindow(rawWindow);
+    void useDesktopHooks().callHook("window:opened", {
+      window: rawWindow,
+      app: this
+    });
+    useDesktopIPC().emit(
+      "window:opened",
+      {
+        windowId,
+        appId: this.id,
+        title: rawWindow.title,
+        workspace: rawWindow.state.workspace
+      },
+      { source: this.id, severity: "info" }
+    );
+    return rawWindow;
+  }
+  closeWindow(windowId) {
+    const win = this.windows.get(windowId);
+    if (!win) return;
+    const closeCtx = {
+      window: win,
+      app: this,
+      cancel: false
+    };
+    void useDesktopHooks().callHook("window:before-close", closeCtx);
+    if (closeCtx.cancel) return;
+    win.dispose();
+    this.windows.delete(windowId);
+    this.openWindowCount.value = this.windows.size;
+    this.storeWindows?.removeWindowState(windowId);
+    this.appActor.send({ type: "CLOSE_WINDOW" });
+    void useDesktopHooks().callHook("window:closed", {
+      windowId,
+      app: this
+    });
+    useDesktopIPC().emit(
+      "window:closed",
+      { windowId, appId: this.id },
+      { source: this.id, severity: "info" }
+    );
+  }
+  closeAllWindows() {
+    for (const windowId of Array.from(this.windows.keys())) {
+      this.closeWindow(windowId);
+    }
+    this.storeWindows?.clearWindows();
+  }
+  setRunning(value) {
+    if (value) {
+      if (!this.isRunning) {
+        this.appActor.send({ type: "LAUNCH" });
+      }
+    } else if (this.isRunning) {
+      this.appActor.send({ type: "CLOSE_APP" });
+    }
+  }
+  suspend() {
+    if (!this.isRunning || this.isSuspended) return;
+    const ctx = {
+      app: this,
+      signal: "SIGSTOP",
+      cancel: false
+    };
+    void useDesktopHooks().callHook("app:before-suspend", ctx);
+    if (ctx.cancel) return;
+    for (const win of this.windows.values()) {
+      win.minimize();
+    }
+    this.appActor.send({ type: "SIGSTOP" });
+    void useDesktopHooks().callHook("app:suspended", { app: this });
+    useDesktopIPC().emit(
+      "process:suspended",
+      { id: this.id, pid: this.pid },
+      { source: "kernel", severity: "warn" }
+    );
+  }
+  resume() {
+    if (!this.isRunning || !this.isSuspended) return;
+    const ctx = {
+      app: this,
+      signal: "SIGCONT",
+      cancel: false
+    };
+    void useDesktopHooks().callHook("app:before-resume", ctx);
+    if (ctx.cancel) return;
+    this.appActor.send({ type: "SIGCONT" });
+    for (const win of this.windows.values()) {
+      win.unminimize();
+      win.focus();
+    }
+    void useDesktopHooks().callHook("app:resumed", { app: this });
+    useDesktopIPC().emit(
+      "process:resumed",
+      { id: this.id, pid: this.pid },
+      { source: "kernel", severity: "info" }
+    );
+  }
+  sendSignal(signal = "SIGTERM") {
+    if (signal === "SIGSTOP") {
+      this.suspend();
+      return;
+    }
+    if (signal === "SIGCONT") {
+      this.resume();
+      return;
+    }
+    const terminateCtx = {
+      app: this,
+      signal,
+      cancel: false
+    };
+    void useDesktopHooks().callHook("app:before-terminate", terminateCtx);
+    if (terminateCtx.cancel && signal !== "SIGKILL") {
+      return;
+    }
+    for (const win of this.windows.values()) {
+      win.dispose();
+    }
+    this.windows.clear();
+    this.openWindowCount.value = 0;
+    this.storeWindows?.clearWindows();
+    this.appActor.send({ type: signal });
+  }
+  async execCommand(command) {
+    return useDesktopCommands().exec(command);
+  }
+}