@owdproject/core 3.4.0 → 4.0.0-alpha.4

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 };

package/dist/shared/core.Di1eFcr_.d.mts

@@ -0,0 +1,114 @@
+import { Hookable } from 'hookable';
+import { DesktopKernelEvent, DesktopRuntimeHooks, WindowConfig, WindowState, WindowLayout, DesktopWorkareaRect, SpatialTransform } from '../types/index.mjs';
+
+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.Pd_Ogt4g.mjs

@@ -0,0 +1,101 @@
+import { createHooks } from 'hookable';
+
+class CoreIPCBus {
+  maxEvents;
+  events = [];
+  listeners = /* @__PURE__ */ new Map();
+  eventCounter = 0;
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.maxEvents = options?.maxEvents ?? 150;
+  }
+  emit(channel, payload, options) {
+    this.eventCounter++;
+    const event = {
+      id: `evt-${Date.now()}-${this.eventCounter}`,
+      timestamp: Date.now(),
+      channel,
+      source: options?.source ?? "kernel",
+      severity: options?.severity ?? "info",
+      payload
+    };
+    this.events = [event, ...this.events.slice(0, this.maxEvents - 1)];
+    const channelSet = this.listeners.get(channel);
+    if (channelSet) {
+      for (const handler of channelSet) {
+        try {
+          handler(event);
+        } catch (err) {
+          console.error(`[@owdproject/core][IPC] Error in listener for "${channel}":`, err);
+        }
+      }
+    }
+    if (channel !== "*") {
+      const wildcardSet = this.listeners.get("*");
+      if (wildcardSet) {
+        for (const handler of wildcardSet) {
+          try {
+            handler(event);
+          } catch (err) {
+            console.error(`[@owdproject/core][IPC] Error in wildcard listener:`, err);
+          }
+        }
+      }
+    }
+    for (const sub of this.subscribers) {
+      try {
+        sub(this.events);
+      } catch {
+      }
+    }
+    return event;
+  }
+  on(channel, handler) {
+    if (!this.listeners.has(channel)) {
+      this.listeners.set(channel, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(channel).add(handler);
+    return () => {
+      this.off(channel, handler);
+    };
+  }
+  off(channel, handler) {
+    const channelSet = this.listeners.get(channel);
+    if (channelSet) {
+      channelSet.delete(handler);
+      if (channelSet.size === 0) {
+        this.listeners.delete(channel);
+      }
+    }
+  }
+  getEvents() {
+    return this.events;
+  }
+  getActiveChannels() {
+    return Array.from(this.listeners.keys());
+  }
+  clear() {
+    this.events = [];
+    for (const sub of this.subscribers) {
+      try {
+        sub(this.events);
+      } catch {
+      }
+    }
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback(this.events);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+}
+const globalIPCBus = new CoreIPCBus();
+
+function createDesktopHooks() {
+  return createHooks();
+}
+const globalDesktopHooks = createDesktopHooks();
+
+export { CoreIPCBus as C, globalIPCBus as a, createDesktopHooks as c, globalDesktopHooks as g };

package/dist/shared/core.b3Xldzyu.mjs

@@ -0,0 +1,29 @@
+import { w as workareaBottom, a as workareaRight } from './core.CsDFgGnX.mjs';
+
+const WINDOW_SNAP_EDGE_PX = 24;
+const WORKSPACE_EDGE_DROP_PX = 32;
+function detectSnapZone(clientX, clientY, workarea, options) {
+  const edge = options?.edgePx ?? WINDOW_SNAP_EDGE_PX;
+  const { x, y, width, height } = workarea;
+  if (width <= 0 || height <= 0) {
+    return null;
+  }
+  const bottom = workareaBottom(workarea);
+  const right = workareaRight(workarea);
+  const nearTop = clientY <= y + edge;
+  const nearBottom = clientY >= bottom - edge;
+  const nearLeft = clientX <= x + edge;
+  const nearRight = clientX >= right - edge;
+  const inWorkspaceEdgeBand = options?.deferSideSnapForWorkspaceEdge === true && typeof globalThis !== "undefined" && "innerWidth" in globalThis && (clientX <= WORKSPACE_EDGE_DROP_PX || clientX >= globalThis.innerWidth - WORKSPACE_EDGE_DROP_PX);
+  if (nearTop && nearLeft) return "top-left";
+  if (nearTop && nearRight) return "top-right";
+  if (nearBottom && nearLeft) return "bottom-left";
+  if (nearBottom && nearRight) return "bottom-right";
+  if (nearTop) return "maximize";
+  if (nearBottom) return "bottom-half";
+  if (nearLeft && !inWorkspaceEdgeBand) return "left-half";
+  if (nearRight && !inWorkspaceEdgeBand) return "right-half";
+  return null;
+}
+
+export { WINDOW_SNAP_EDGE_PX as W, WORKSPACE_EDGE_DROP_PX as a, detectSnapZone as d };