@owdproject/core 3.3.1 → 4.0.0-alpha.3

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

package/dist/types/index.d.mts

@@ -0,0 +1,266 @@
+/**
+ * @owdproject/core - Framework-Agnostic Types
+ */
+type WindowLayout = 'normal' | 'maximize' | 'bottom-half' | 'left-half' | 'right-half' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+type SnapZoneHint = Exclude<WindowLayout, 'normal'>;
+interface WindowBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface DesktopWorkareaRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type WindowSizeValue = number | string | undefined;
+interface WindowSize {
+    width?: WindowSizeValue;
+    height?: WindowSizeValue;
+    minWidth?: WindowSizeValue;
+    minHeight?: WindowSizeValue;
+    maxWidth?: WindowSizeValue;
+    maxHeight?: WindowSizeValue;
+}
+interface WindowPosition {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+interface SpatialPoint3D {
+    x: number;
+    y: number;
+    z: number;
+}
+interface SpatialEuler {
+    pitch: number;
+    yaw: number;
+    roll: number;
+}
+interface SpatialTransform {
+    position: SpatialPoint3D;
+    rotation?: SpatialEuler;
+    scale?: SpatialPoint3D;
+    distance?: number;
+    curveRadius?: number;
+}
+type SpatialLayoutMode = 'cylinder' | 'sphere' | 'carousel' | 'depth-stack';
+interface WindowConfig {
+    title?: string;
+    category?: string;
+    icon?: string;
+    component?: any;
+    position?: WindowPosition;
+    size: WindowSize;
+    minimizable?: boolean;
+    maximized?: boolean;
+    maximizable?: boolean;
+    destroyable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    spatial?: SpatialTransform;
+    overridable?: Partial<Record<'position' | 'size' | 'maximized' | 'draggable' | 'resizable' | 'destroyable' | 'minimizable', boolean>>;
+}
+interface WindowOverride {
+    title?: string;
+    windowTitle?: string;
+    icon?: string;
+}
+interface WindowState {
+    id: string;
+    createdAt: number;
+    category?: string;
+    workspace: string;
+    position?: WindowPosition;
+    size?: WindowSize;
+    spatial?: SpatialTransform;
+    focused: boolean;
+    dragging?: boolean;
+    resizing?: boolean;
+    active?: boolean;
+    minimizable?: boolean;
+    maximized?: boolean;
+    maximizable?: boolean;
+    destroyable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    layout?: WindowLayout;
+    boundsBeforeLayout?: WindowBounds;
+}
+interface WindowStoredState {
+    model: string;
+    state: WindowState;
+    meta: any;
+}
+type ApplicationEntryVisibility = 'primary' | 'secondary' | 'hidden';
+interface ApplicationEntry {
+    title?: string;
+    icon?: string;
+    category?: string;
+    visibility?: ApplicationEntryVisibility;
+    command: string | any;
+}
+type ApplicationPermission = string;
+interface ApplicationConfigProvide {
+    name: string;
+    entry: string;
+    command?: string;
+}
+interface ApplicationConfig {
+    id: string;
+    title: string;
+    icon?: string;
+    category?: string;
+    version?: string;
+    description?: string;
+    provides?: ApplicationConfigProvide;
+    singleton?: boolean;
+    meta?: Record<string, any>;
+    permissions?: ApplicationPermission[];
+    windows?: {
+        [key: string]: WindowConfig;
+    };
+    entries: {
+        [key: string]: ApplicationEntry;
+    };
+    commands?: {
+        [key: string]: (app: any, args: any) => void;
+    };
+    terminal?: {
+        [commandName: string]: Omit<DesktopCommand, 'name' | 'applicationId'>;
+    };
+    onReady?(app: any): void | Promise<void>;
+    onLaunch?(app: any): void | Promise<void>;
+    onRestore?(app: any): void | Promise<void>;
+    onClose?(app: any): void | Promise<void>;
+}
+interface DesktopCommandArg {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+interface DesktopCommandOption {
+    flag: string;
+    description?: string;
+}
+interface DesktopCommand {
+    name: string;
+    applicationId: string;
+    description?: string;
+    usage?: string;
+    args?: DesktopCommandArg[];
+    options?: DesktopCommandOption[];
+}
+interface CommandOutput {
+    message: string;
+    isError?: boolean;
+}
+interface DesktopKernelEvent {
+    id: string;
+    timestamp: number;
+    channel: string;
+    source: string;
+    severity: 'info' | 'warn' | 'error';
+    payload?: any;
+}
+interface DesktopAppDefineContext {
+    id: string;
+    config: ApplicationConfig;
+    cancel?: boolean;
+}
+interface DesktopAppLaunchContext {
+    app: any;
+    entryKey?: string;
+    argument?: string;
+    cancel?: boolean;
+}
+interface DesktopAppSignalContext {
+    app: any;
+    signal?: 'SIGTERM' | 'SIGKILL' | 'SIGSTOP' | 'SIGCONT';
+    cancel?: boolean;
+}
+interface DesktopWindowOpenContext {
+    app: any;
+    model: string;
+    config: WindowConfig;
+    meta?: Record<string, any>;
+    cancel?: boolean;
+}
+interface DesktopWindowCloseContext {
+    window: any;
+    app: any;
+    cancel?: boolean;
+}
+interface DesktopCommandExecContext {
+    input: string;
+    commandName: string;
+    args: string[];
+    cancel?: boolean;
+    overrideOutput?: CommandOutput;
+}
+interface DesktopWorkspaceSwitchContext {
+    from: string;
+    to: string;
+    cancel?: boolean;
+}
+interface DesktopRuntimeHooks {
+    'app:before-define': (ctx: DesktopAppDefineContext) => Promise<void> | void;
+    'app:defined': (payload: {
+        app: any;
+    }) => Promise<void> | void;
+    'app:before-launch': (ctx: DesktopAppLaunchContext) => Promise<void> | void;
+    'app:launched': (payload: {
+        app: any;
+        pid: number | null;
+    }) => Promise<void> | void;
+    'app:before-suspend': (ctx: DesktopAppSignalContext) => Promise<void> | void;
+    'app:suspended': (payload: {
+        app: any;
+    }) => Promise<void> | void;
+    'app:before-resume': (ctx: DesktopAppSignalContext) => Promise<void> | void;
+    'app:resumed': (payload: {
+        app: any;
+    }) => Promise<void> | void;
+    'app:before-terminate': (ctx: DesktopAppSignalContext) => Promise<void> | void;
+    'app:terminated': (payload: {
+        id: string;
+        title: string;
+        pid: number | null;
+    }) => Promise<void> | void;
+    'window:before-open': (ctx: DesktopWindowOpenContext) => Promise<void> | void;
+    'window:opened': (payload: {
+        window: any;
+        app: any;
+    }) => Promise<void> | void;
+    'window:focused': (payload: {
+        window: any;
+        previousWindow?: any;
+    }) => Promise<void> | void;
+    'window:blurred': (payload: {
+        window: any;
+    }) => Promise<void> | void;
+    'window:layout-change': (payload: {
+        window: any;
+        layout: WindowLayout;
+    }) => Promise<void> | void;
+    'window:before-close': (ctx: DesktopWindowCloseContext) => Promise<void> | void;
+    'window:closed': (payload: {
+        windowId: string;
+        app: any;
+    }) => Promise<void> | void;
+    'command:before-exec': (ctx: DesktopCommandExecContext) => Promise<void> | void;
+    'command:after-exec': (payload: {
+        input: string;
+        commandName: string;
+        output: CommandOutput | void;
+    }) => Promise<void> | void;
+    'workspace:before-switch': (ctx: DesktopWorkspaceSwitchContext) => Promise<void> | void;
+    'workspace:switched': (payload: {
+        from: string;
+        to: string;
+    }) => Promise<void> | void;
+}
+
+export type { ApplicationConfig, ApplicationConfigProvide, ApplicationEntry, ApplicationEntryVisibility, ApplicationPermission, CommandOutput, DesktopAppDefineContext, DesktopAppLaunchContext, DesktopAppSignalContext, DesktopCommand, DesktopCommandArg, DesktopCommandExecContext, DesktopCommandOption, DesktopKernelEvent, DesktopRuntimeHooks, DesktopWindowCloseContext, DesktopWindowOpenContext, DesktopWorkareaRect, DesktopWorkspaceSwitchContext, SnapZoneHint, SpatialEuler, SpatialLayoutMode, SpatialPoint3D, SpatialTransform, WindowBounds, WindowConfig, WindowLayout, WindowOverride, WindowPosition, WindowSize, WindowSizeValue, WindowState, WindowStoredState };