@owdproject/core 3.4.0 → 4.0.0-alpha.3

package/dist/shared/core.B1XxB289.mjs

@@ -0,0 +1,239 @@
+import { g as globalDesktopHooks, a as globalIPCBus } from './core.Pd_Ogt4g.mjs';
+
+function shellEscape(str) {
+  if (str === "") {
+    return "''";
+  }
+  return `${str.replace(/'/g, `'\\''`)}`;
+}
+function padEnd(str, len) {
+  return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function formatDuration(ms) {
+  const totalSec = Math.max(0, Math.floor(ms / 1e3));
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return `${String(m).padStart(2, "0")}m ${String(s).padStart(2, "0")}s`;
+}
+function parseCommandLine(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { name: "", args: [] };
+  }
+  const [name = "", ...args] = trimmed.split(/\s+/);
+  return { name, args };
+}
+
+class DesktopKeybindings {
+  windowManager;
+  workareaProvider;
+  customHandlers = /* @__PURE__ */ new Map();
+  isListening = false;
+  listenerRef;
+  constructor(windowManager, options) {
+    this.windowManager = windowManager;
+    this.workareaProvider = options?.workareaProvider;
+  }
+  register(shortcut, handler) {
+    this.customHandlers.set(shortcut.toLowerCase(), handler);
+    return this;
+  }
+  listen() {
+    if (typeof window === "undefined" || this.isListening) {
+      return () => this.stop();
+    }
+    this.isListening = true;
+    this.listenerRef = (e) => this.handleKeyDown(e);
+    window.addEventListener("keydown", this.listenerRef);
+    return () => this.stop();
+  }
+  stop() {
+    if (typeof window !== "undefined" && this.listenerRef) {
+      window.removeEventListener("keydown", this.listenerRef);
+    }
+    this.isListening = false;
+  }
+  handleKeyDown(e) {
+    const activeEl = document.activeElement;
+    if (activeEl && (activeEl.tagName === "INPUT" || activeEl.tagName === "TEXTAREA" || activeEl.isContentEditable)) {
+      return;
+    }
+    const isMetaOrCtrl = e.metaKey || e.ctrlKey;
+    const isAlt = e.altKey;
+    const isShift = e.shiftKey;
+    const key = e.key.toLowerCase();
+    if (isAlt && key === "tab") {
+      e.preventDefault();
+      this.cycleWindowFocus(isShift ? "backward" : "forward");
+      return;
+    }
+    if (isMetaOrCtrl) {
+      const focused = this.windowManager.focusedWindow;
+      const workarea = this.workareaProvider?.() ?? {
+        x: 0,
+        y: 0,
+        width: typeof window !== "undefined" ? window.innerWidth : 1920,
+        height: typeof window !== "undefined" ? window.innerHeight : 1080
+      };
+      if (key === "arrowleft" && focused) {
+        e.preventDefault();
+        this.windowManager.snapWindow(focused.id, "left-half", workarea);
+        return;
+      }
+      if (key === "arrowright" && focused) {
+        e.preventDefault();
+        this.windowManager.snapWindow(focused.id, "right-half", workarea);
+        return;
+      }
+      if (key === "arrowup" && focused) {
+        e.preventDefault();
+        if (!focused.state.maximized) {
+          focused.maximize();
+        }
+        return;
+      }
+      if (key === "arrowdown" && focused) {
+        e.preventDefault();
+        if (focused.state.maximized) {
+          focused.unmaximize();
+        } else {
+          focused.minimize();
+        }
+        return;
+      }
+      if (key === "w" && focused && !e.shiftKey) {
+        e.preventDefault();
+        this.windowManager.closeWindow(focused.id);
+        return;
+      }
+    }
+  }
+  cycleWindowFocus(direction) {
+    const activeWindows = Array.from(this.windowManager.getSnapshot()).filter((w) => w.active);
+    if (activeWindows.length <= 1) return;
+    const focusedId = this.windowManager.focusedWindow?.id;
+    const currentIndex = activeWindows.findIndex((w) => w.id === focusedId);
+    let nextIndex = 0;
+    if (direction === "forward") {
+      nextIndex = (currentIndex + 1) % activeWindows.length;
+    } else {
+      nextIndex = (currentIndex - 1 + activeWindows.length) % activeWindows.length;
+    }
+    const nextWin = activeWindows[nextIndex];
+    if (nextWin) {
+      this.windowManager.focusWindow(nextWin.id);
+    }
+  }
+}
+
+class DesktopCommands {
+  commands = /* @__PURE__ */ new Map();
+  snapshotCache = Object.freeze([]);
+  subscribers = /* @__PURE__ */ new Set();
+  hooks;
+  ipc;
+  constructor(options) {
+    this.hooks = options?.hooks ?? globalDesktopHooks;
+    this.ipc = options?.ipc ?? globalIPCBus;
+  }
+  getSnapshot() {
+    return this.snapshotCache;
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.getSnapshot());
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notify() {
+    this.snapshotCache = Object.freeze(
+      Array.from(this.commands.values()).map(({ handler: _h, ...meta }) => Object.freeze({ ...meta }))
+    );
+    const snapshot = this.getSnapshot();
+    for (const sub of this.subscribers) {
+      try {
+        sub(snapshot);
+      } catch {
+      }
+    }
+  }
+  register(command, handler) {
+    this.commands.set(command.name, {
+      ...command,
+      handler
+    });
+    this.notify();
+    return () => {
+      this.unregister(command.name);
+    };
+  }
+  unregister(name) {
+    const deleted = this.commands.delete(name);
+    if (deleted) {
+      this.notify();
+    }
+    return deleted;
+  }
+  has(name) {
+    return this.commands.has(name);
+  }
+  getCommands() {
+    return this.getSnapshot();
+  }
+  async exec(input) {
+    const { name, args } = parseCommandLine(input);
+    if (!name) return void 0;
+    const execCtx = {
+      input,
+      commandName: name,
+      args,
+      cancel: false,
+      overrideOutput: void 0
+    };
+    await this.hooks.callHook("command:before-exec", execCtx);
+    if (execCtx.cancel) {
+      return execCtx.overrideOutput ?? {
+        message: `Command "${name}" execution cancelled by policy.`,
+        isError: true
+      };
+    }
+    const registered = this.commands.get(name);
+    if (!registered) {
+      const notFoundOutput = {
+        message: `${name}: command not found`,
+        isError: true
+      };
+      await this.hooks.callHook("command:after-exec", {
+        input,
+        commandName: name,
+        output: notFoundOutput
+      });
+      return notFoundOutput;
+    }
+    try {
+      const result = await registered.handler(args, input);
+      const output = typeof result === "string" ? { message: result, isError: false } : result;
+      this.ipc.emit("command:executed", { command: name, args }, { source: "commands" });
+      await this.hooks.callHook("command:after-exec", {
+        input,
+        commandName: name,
+        output
+      });
+      return output;
+    } catch (err) {
+      const errorOutput = {
+        message: err?.message || String(err),
+        isError: true
+      };
+      await this.hooks.callHook("command:after-exec", {
+        input,
+        commandName: name,
+        output: errorOutput
+      });
+      return errorOutput;
+    }
+  }
+}
+
+export { DesktopCommands as D, DesktopKeybindings as a, parseCommandLine as b, formatDuration as f, padEnd as p, shellEscape as s };

package/dist/shared/core.B3mp7ztE.mjs

@@ -0,0 +1,237 @@
+import { createMachine, assign } from 'xstate';
+
+const windowMachine = createMachine({
+  id: "window",
+  initial: "normal",
+  context: ({ input }) => ({
+    wasMaximized: false,
+    config: input?.config
+  }),
+  states: {
+    normal: {
+      entry: assign({ wasMaximized: false }),
+      initial: "focused",
+      states: {
+        focused: {
+          initial: "idle",
+          states: {
+            idle: {
+              on: {
+                DRAG_START: "dragging",
+                RESIZE_START: "resizing"
+              }
+            },
+            dragging: {
+              on: {
+                DRAG_END: "idle",
+                SNAP_DROP: "idle"
+              }
+            },
+            resizing: {
+              on: {
+                RESIZE_END: "idle"
+              }
+            }
+          },
+          on: {
+            BLUR: "unfocused",
+            MAXIMIZE: "#window.maximized.focused",
+            MINIMIZE: "#window.minimized"
+          }
+        },
+        unfocused: {
+          on: {
+            FOCUS: "focused",
+            MAXIMIZE: "#window.maximized.unfocused",
+            MINIMIZE: "#window.minimized"
+          }
+        }
+      },
+      on: {
+        DESTROY: "closed"
+      }
+    },
+    maximized: {
+      entry: assign({ wasMaximized: true }),
+      initial: "focused",
+      states: {
+        focused: {
+          on: {
+            BLUR: "unfocused",
+            RESTORE: "#window.normal.focused",
+            MINIMIZE: "#window.minimized"
+          }
+        },
+        unfocused: {
+          on: {
+            FOCUS: "focused",
+            RESTORE: "#window.normal.unfocused",
+            MINIMIZE: "#window.minimized"
+          }
+        }
+      },
+      on: {
+        DESTROY: "closed"
+      }
+    },
+    minimized: {
+      on: {
+        RESTORE: [
+          {
+            target: "maximized.focused",
+            guard: ({ context }) => context.wasMaximized
+          },
+          {
+            target: "normal.focused"
+          }
+        ],
+        DESTROY: "closed"
+      }
+    },
+    closed: {
+      type: "final"
+    }
+  }
+});
+
+const applicationMachine = createMachine({
+  id: "application",
+  initial: "idle",
+  context: ({ input }) => ({
+    id: input?.id ?? "",
+    config: input?.config,
+    windowCount: 0
+  }),
+  states: {
+    idle: {
+      on: {
+        LAUNCH: "initializing",
+        RESTORE: "initializing",
+        OPEN_WINDOW: {
+          target: "running.active",
+          actions: assign({
+            windowCount: ({ context }) => context.windowCount + 1
+          })
+        }
+      }
+    },
+    initializing: {
+      on: {
+        INITIALIZED: [
+          {
+            target: "running.active",
+            guard: ({ context }) => context.windowCount > 0
+          },
+          {
+            target: "ready"
+          }
+        ],
+        OPEN_WINDOW: {
+          actions: assign({
+            windowCount: ({ context }) => context.windowCount + 1
+          })
+        },
+        INIT_FAILED: "error"
+      }
+    },
+    ready: {
+      on: {
+        LAUNCH: "running.active",
+        START_PROCESS: "running.active",
+        OPEN_WINDOW: {
+          target: "running.active",
+          actions: assign({
+            windowCount: ({ context }) => context.windowCount + 1
+          })
+        },
+        CLOSE_APP: "terminating"
+      }
+    },
+    running: {
+      initial: "active",
+      states: {
+        active: {
+          on: {
+            MINIMIZE_ALL: "suspended",
+            SUSPEND: "suspended",
+            SIGSTOP: "suspended",
+            CLOSE_WINDOW: [
+              {
+                target: "#application.terminating",
+                guard: ({ context }) => context.windowCount - 1 <= 0,
+                actions: assign({
+                  windowCount: () => 0
+                })
+              },
+              {
+                actions: assign({
+                  windowCount: ({ context }) => Math.max(0, context.windowCount - 1)
+                })
+              }
+            ],
+            OPEN_WINDOW: {
+              actions: assign({
+                windowCount: ({ context }) => context.windowCount + 1
+              })
+            }
+          }
+        },
+        suspended: {
+          on: {
+            RESTORE_WINDOW: "active",
+            RESUME: "active",
+            SIGCONT: "active",
+            LAUNCH: "active",
+            OPEN_WINDOW: {
+              target: "active",
+              actions: assign({
+                windowCount: ({ context }) => context.windowCount + 1
+              })
+            },
+            CLOSE_WINDOW: [
+              {
+                target: "#application.terminating",
+                guard: ({ context }) => context.windowCount - 1 <= 0,
+                actions: assign({
+                  windowCount: () => 0
+                })
+              },
+              {
+                actions: assign({
+                  windowCount: ({ context }) => Math.max(0, context.windowCount - 1)
+                })
+              }
+            ]
+          }
+        }
+      },
+      on: {
+        CLOSE_APP: "terminating",
+        SIGTERM: "terminating",
+        SIGKILL: "terminating"
+      }
+    },
+    terminating: {
+      entry: assign({
+        windowCount: () => 0
+      }),
+      on: {
+        TERMINATED: "ready"
+      }
+    },
+    error: {
+      on: {
+        RESET: "ready",
+        LAUNCH: "running.active",
+        OPEN_WINDOW: {
+          target: "running.active",
+          actions: assign({
+            windowCount: ({ context }) => context.windowCount + 1
+          })
+        }
+      }
+    }
+  }
+});
+
+export { applicationMachine as a, windowMachine as w };

package/dist/shared/core.BOvFdEVQ.d.ts

@@ -0,0 +1,114 @@
+import { Hookable } from 'hookable';
+import { DesktopKernelEvent, DesktopRuntimeHooks, WindowConfig, WindowState, WindowLayout, DesktopWorkareaRect, SpatialTransform } from '../types/index.js';
+
+type EventHandler = (event: DesktopKernelEvent) => void;
+declare class CoreIPCBus {
+    private readonly maxEvents;
+    private events;
+    private readonly listeners;
+    private eventCounter;
+    private subscribers;
+    constructor(options?: {
+        maxEvents?: number;
+    });
+    emit(channel: string, payload?: any, options?: {
+        source?: string;
+        severity?: 'info' | 'warn' | 'error';
+    }): DesktopKernelEvent;
+    on(channel: string, handler: EventHandler): () => void;
+    off(channel: string, handler: EventHandler): void;
+    getEvents(): DesktopKernelEvent[];
+    getActiveChannels(): string[];
+    clear(): void;
+    subscribe(callback: (events: DesktopKernelEvent[]) => void): () => void;
+}
+declare const globalIPCBus: CoreIPCBus;
+
+declare class WindowInstance {
+    readonly id: string;
+    readonly model: string;
+    readonly applicationId?: string;
+    config: WindowConfig;
+    state: WindowState;
+    meta: Record<string, any>;
+    private actor;
+    private isDisposed;
+    private subscribers;
+    constructor(options: {
+        id: string;
+        model: string;
+        applicationId?: string;
+        config: WindowConfig;
+        initialState?: Partial<WindowState>;
+        meta?: Record<string, any>;
+        workspace?: string;
+    });
+    private updateState;
+    getSnapshot(): WindowState;
+    subscribe(callback: (snapshot: WindowState) => void): () => void;
+    private notify;
+    get stateValue(): string;
+    setPosition(data: {
+        x: number;
+        y: number;
+        z?: number;
+    }): void;
+    setSize(data: {
+        width: number;
+        height: number;
+    }): void;
+    setFocus(value: boolean): void;
+    minimize(): boolean;
+    unminimize(): boolean;
+    maximize(): boolean;
+    unmaximize(): boolean;
+    toggleMaximize(): boolean;
+    startDrag(): void;
+    stopDrag(): void;
+    startResize(): void;
+    stopResize(): void;
+    setLayout(layout: WindowLayout, workarea?: DesktopWorkareaRect): boolean;
+    clearLayout(): boolean;
+    saveBoundsBeforeLayout(): void;
+    setWorkspace(workspaceId: string): void;
+    get workspace(): string;
+    setSpatialTransform(transform: SpatialTransform): void;
+    get spatial(): SpatialTransform | undefined;
+    dispose(): void;
+}
+declare class WindowManager {
+    private windows;
+    private snapshotCache;
+    private zIndexCounter;
+    private subscribers;
+    private hooks;
+    private ipc;
+    constructor(options?: {
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    getSnapshot(): WindowInstance[];
+    subscribe(callback: (windows: WindowInstance[]) => void): () => void;
+    private notify;
+    get(id: string): WindowInstance | undefined;
+    get focusedWindow(): WindowInstance | undefined;
+    incrementZIndex(): number;
+    addWindow(instance: WindowInstance): void;
+    createWindow(options: {
+        id: string;
+        model: string;
+        applicationId?: string;
+        config: WindowConfig;
+        initialState?: Partial<WindowState>;
+        meta?: Record<string, any>;
+        workspace?: string;
+    }): WindowInstance;
+    focusWindow(id: string): void;
+    closeWindow(id: string): boolean;
+    closeAllWindows(): void;
+    tileWindows(mode: "horizontal" | "vertical" | "grid" | undefined, workarea: DesktopWorkareaRect, workspaceId?: string, gap?: number): number;
+    setSpatialTransform(windowId: string, transform: SpatialTransform): void;
+}
+
+export { CoreIPCBus as C, WindowManager as W, WindowInstance as a, globalIPCBus as g };
+export type { EventHandler as E };

package/dist/shared/core.CsDFgGnX.mjs

@@ -0,0 +1,40 @@
+function workareaBottom(workarea) {
+  return workarea.y + workarea.height;
+}
+function workareaRight(workarea) {
+  return workarea.x + workarea.width;
+}
+function computeSnapRect(zone, workarea) {
+  const { x, y, width, height } = workarea;
+  const halfW = Math.floor(width / 2);
+  const halfH = Math.floor(height / 2);
+  switch (zone) {
+    case "maximize":
+      return { x, y, width, height };
+    case "left-half":
+      return { x, y, width: halfW, height };
+    case "right-half":
+      return { x: x + halfW, y, width: width - halfW, height };
+    case "bottom-half":
+      return { x, y: y + halfH, width, height: height - halfH };
+    case "top-left":
+      return { x, y, width: halfW, height: halfH };
+    case "top-right":
+      return { x: x + halfW, y, width: width - halfW, height: halfH };
+    case "bottom-left":
+      return { x, y: y + halfH, width: halfW, height: height - halfH };
+    case "bottom-right":
+      return {
+        x: x + halfW,
+        y: y + halfH,
+        width: width - halfW,
+        height: height - halfH
+      };
+    default: {
+      const _exhaustive = zone;
+      return _exhaustive;
+    }
+  }
+}
+
+export { workareaRight as a, computeSnapRect as c, workareaBottom as w };