@owdproject/core 3.4.0 → 4.0.0-alpha.3

package/dist/managers/index.d.ts

@@ -0,0 +1,117 @@
+import { W as WindowManager, a as WindowInstance } from '../shared/core.BOvFdEVQ.js';
+import { CoreIPCBus } from '../events/index.js';
+import { Hookable } from 'hookable';
+import { DesktopWorkareaRect, DesktopRuntimeHooks, ApplicationConfig, ApplicationPermission, WindowState } from '../types/index.js';
+
+interface WorkspaceState {
+    readonly workspaces: readonly string[];
+    readonly active: string;
+    readonly workarea: DesktopWorkareaRect;
+}
+declare class WorkspaceManager {
+    private state;
+    private subscribers;
+    private hooks;
+    private ipc;
+    constructor(options?: {
+        workspaces?: string[];
+        active?: string;
+        workarea?: DesktopWorkareaRect;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    private updateState;
+    getSnapshot(): WorkspaceState;
+    subscribe(callback: (state: WorkspaceState) => void): () => void;
+    private notify;
+    get activeWorkspace(): string;
+    get workspaces(): string[];
+    get workarea(): DesktopWorkareaRect;
+    setWorkspace(workspaceId: string): Promise<boolean>;
+    setWorkarea(workarea: DesktopWorkareaRect): void;
+    addWorkspace(id: string): void;
+    removeWorkspace(id: string): boolean;
+}
+
+interface ApplicationProcessSnapshot {
+    readonly id: string;
+    readonly title: string;
+    readonly icon?: string;
+    readonly category?: string;
+    readonly stateValue: string;
+    readonly pid: number | null;
+    readonly startedAt: number | null;
+    readonly isRunning: boolean;
+    readonly isSuspended: boolean;
+    readonly windowIds: readonly string[];
+}
+declare class ApplicationInstance {
+    readonly id: string;
+    readonly config: ApplicationConfig;
+    private actor;
+    private _pid;
+    private _startedAt;
+    private _windowIds;
+    private snapshot;
+    private subscribers;
+    private windowManager;
+    private workspaceManager?;
+    private hooks;
+    private ipc;
+    private allocatePid;
+    constructor(options: {
+        config: ApplicationConfig;
+        windowManager: WindowManager;
+        workspaceManager?: WorkspaceManager;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+        allocatePid: () => number;
+    });
+    private computeSnapshot;
+    private refreshSnapshot;
+    private notify;
+    getSnapshot(): ApplicationProcessSnapshot;
+    subscribe(callback: (snapshot: ApplicationProcessSnapshot) => void): () => void;
+    get pid(): number | null;
+    get startedAt(): number | null;
+    get stateValue(): string;
+    get isRunning(): boolean;
+    get isSuspended(): boolean;
+    hasPermission(permission: ApplicationPermission): boolean;
+    private ensureProcessStarted;
+    launch(entryKey?: string, argument?: string): Promise<boolean>;
+    openWindow(model: string, meta?: Record<string, any>, initialState?: Partial<WindowState>): Promise<WindowInstance | undefined>;
+    closeWindow(windowId: string): Promise<boolean>;
+    closeAllWindows(): void;
+    suspend(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    terminate(signal?: 'SIGTERM' | 'SIGKILL'): Promise<boolean>;
+}
+declare class ApplicationManager {
+    private apps;
+    private snapshotCache;
+    private pidCounter;
+    private subscribers;
+    private windowManager;
+    private workspaceManager?;
+    private hooks;
+    private ipc;
+    constructor(options: {
+        windowManager: WindowManager;
+        workspaceManager?: WorkspaceManager;
+        hooks?: Hookable<DesktopRuntimeHooks>;
+        ipc?: CoreIPCBus;
+    });
+    getSnapshot(): ApplicationInstance[];
+    subscribe(callback: (apps: ApplicationInstance[]) => void): () => void;
+    private notify;
+    register(config: ApplicationConfig): ApplicationInstance;
+    get(id: string): ApplicationInstance | undefined;
+    getByPid(pid: number): ApplicationInstance | undefined;
+    get runningApps(): ApplicationInstance[];
+    launch(id: string, entryKey?: string, argument?: string): Promise<boolean>;
+    terminate(idOrPid: string | number, signal?: 'SIGTERM' | 'SIGKILL'): Promise<boolean>;
+}
+
+export { ApplicationInstance, ApplicationManager, WindowInstance, WindowManager, WorkspaceManager };
+export type { ApplicationProcessSnapshot, WorkspaceState };

package/dist/managers/index.mjs

@@ -0,0 +1,6 @@
+export { A as ApplicationInstance, a as ApplicationManager, W as WindowInstance, b as WindowManager, c as WorkspaceManager } from '../shared/core.B0B0KfVK.mjs';
+import 'xstate';
+import '../shared/core.B3mp7ztE.mjs';
+import '../shared/core.CsDFgGnX.mjs';
+import '../shared/core.Pd_Ogt4g.mjs';
+import 'hookable';

package/dist/session/index.d.mts

@@ -0,0 +1,57 @@
+import { WindowManager } from '../index.mjs';
+import 'hookable';
+import '../types/index.mjs';
+
+/**
+ * @owdproject/core - Desktop Session Serializer & Hydration Engine
+ * Allows full state capture, persistence (LocalStorage / Database), and instant restore
+ * across sessions, devices, and frameworks.
+ */
+
+interface DesktopSerializedWindow {
+    id: string;
+    model: string;
+    workspace: string;
+    title?: string;
+    position?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    size?: {
+        width?: any;
+        height?: any;
+    };
+    maximized?: boolean;
+    layout?: any;
+    spatial?: any;
+    focused?: boolean;
+    meta?: Record<string, any>;
+}
+interface DesktopSerializedSession {
+    version: number;
+    timestamp: number;
+    activeWorkspace?: string;
+    windows: DesktopSerializedWindow[];
+}
+declare class DesktopSessionManager {
+    static readonly CURRENT_VERSION = 1;
+    /**
+     * Serializes current WindowManager state into a JSON-compatible object.
+     */
+    static serialize(windowManager: WindowManager, options?: {
+        activeWorkspace?: string;
+    }): DesktopSerializedSession;
+    /**
+     * Restores windows from a serialized session into a WindowManager instance.
+     */
+    static restore(windowManager: WindowManager, session: DesktopSerializedSession, options?: {
+        componentResolver?: (model: string) => any;
+    }): {
+        restoredCount: number;
+        errors: string[];
+    };
+}
+
+export { DesktopSessionManager };
+export type { DesktopSerializedSession, DesktopSerializedWindow };

package/dist/session/index.d.ts

@@ -0,0 +1,57 @@
+import { WindowManager } from '../index.js';
+import 'hookable';
+import '../types/index.js';
+
+/**
+ * @owdproject/core - Desktop Session Serializer & Hydration Engine
+ * Allows full state capture, persistence (LocalStorage / Database), and instant restore
+ * across sessions, devices, and frameworks.
+ */
+
+interface DesktopSerializedWindow {
+    id: string;
+    model: string;
+    workspace: string;
+    title?: string;
+    position?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    size?: {
+        width?: any;
+        height?: any;
+    };
+    maximized?: boolean;
+    layout?: any;
+    spatial?: any;
+    focused?: boolean;
+    meta?: Record<string, any>;
+}
+interface DesktopSerializedSession {
+    version: number;
+    timestamp: number;
+    activeWorkspace?: string;
+    windows: DesktopSerializedWindow[];
+}
+declare class DesktopSessionManager {
+    static readonly CURRENT_VERSION = 1;
+    /**
+     * Serializes current WindowManager state into a JSON-compatible object.
+     */
+    static serialize(windowManager: WindowManager, options?: {
+        activeWorkspace?: string;
+    }): DesktopSerializedSession;
+    /**
+     * Restores windows from a serialized session into a WindowManager instance.
+     */
+    static restore(windowManager: WindowManager, session: DesktopSerializedSession, options?: {
+        componentResolver?: (model: string) => any;
+    }): {
+        restoredCount: number;
+        errors: string[];
+    };
+}
+
+export { DesktopSessionManager };
+export type { DesktopSerializedSession, DesktopSerializedWindow };

package/dist/session/index.mjs

@@ -0,0 +1,65 @@
+class DesktopSessionManager {
+  static CURRENT_VERSION = 1;
+  /**
+   * Serializes current WindowManager state into a JSON-compatible object.
+   */
+  static serialize(windowManager, options) {
+    const windows = windowManager.getSnapshot();
+    const serializedWindows = windows.filter((win) => win.state.active).map((win) => {
+      return {
+        id: win.id,
+        model: win.model ?? "window",
+        workspace: win.state.workspace,
+        title: win.config.title,
+        position: win.state.position,
+        size: win.state.size,
+        maximized: win.state.maximized,
+        layout: win.state.layout,
+        spatial: win.state.spatial,
+        focused: win.state.focused
+      };
+    });
+    return {
+      version: DesktopSessionManager.CURRENT_VERSION,
+      timestamp: Date.now(),
+      activeWorkspace: options?.activeWorkspace,
+      windows: serializedWindows
+    };
+  }
+  /**
+   * Restores windows from a serialized session into a WindowManager instance.
+   */
+  static restore(windowManager, session, options) {
+    const errors = [];
+    let restoredCount = 0;
+    if (!session || typeof session !== "object" || !Array.isArray(session.windows)) {
+      return { restoredCount: 0, errors: ["Invalid session format"] };
+    }
+    for (const item of session.windows) {
+      try {
+        const component = options?.componentResolver?.(item.model);
+        windowManager.createWindow({
+          id: item.id,
+          model: item.model,
+          config: {
+            title: item.title,
+            component
+          },
+          initialState: {
+            workspace: item.workspace,
+            position: item.position,
+            size: item.size ?? { width: 640, height: 480 },
+            maximized: item.maximized,
+            spatial: item.spatial
+          }
+        });
+        restoredCount++;
+      } catch (err) {
+        errors.push(`Failed to restore window ${item.id}: ${err?.message || String(err)}`);
+      }
+    }
+    return { restoredCount, errors };
+  }
+}
+
+export { DesktopSessionManager };