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

package/dist/runtime/stores/storeDesktopWorkspace.js

@@ -0,0 +1,91 @@
+import { computed, ref } from "vue";
+import { defineStore } from "pinia";
+import { useDesktopHooks } from "../composables/useDesktopHooks.js";
+import { useDesktopIPC } from "../composables/useDesktopIPC.js";
+export const EMPTY_DESKTOP_WORKAREA = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0
+};
+export const useDesktopWorkspaceStore = defineStore("desktop/workspace", () => {
+  const list = ref([
+    "workspace-1",
+    "workspace-2",
+    "workspace-3",
+    "workspace-4"
+  ]);
+  const active = ref("workspace-1");
+  const overview = ref(false);
+  const workarea = ref({ ...EMPTY_DESKTOP_WORKAREA });
+  const workspaceActiveIndex = computed(
+    () => list.value.indexOf(active.value)
+  );
+  function setWorkspace(workspaceId) {
+    if (!list.value.includes(workspaceId)) return false;
+    const previous = active.value;
+    if (previous === workspaceId) return true;
+    const { callHook } = useDesktopHooks();
+    const switchCtx = {
+      from: previous,
+      to: workspaceId,
+      cancel: false
+    };
+    void callHook("workspace:before-switch", switchCtx);
+    if (switchCtx.cancel) return false;
+    active.value = switchCtx.to;
+    void callHook("workspace:switched", { from: previous, to: switchCtx.to });
+    useDesktopIPC().emit(
+      "workspace:switched",
+      { from: previous, to: switchCtx.to },
+      { source: "workspace-store", severity: "info" }
+    );
+    return true;
+  }
+  function setOverview(value) {
+    overview.value = value;
+  }
+  function toggleOverview() {
+    overview.value = !overview.value;
+  }
+  function setWorkarea(rect) {
+    workarea.value = { ...rect };
+  }
+  function addWorkspace(id) {
+    const nextId = id || `workspace-${list.value.length + 1}`;
+    if (!list.value.includes(nextId)) {
+      list.value.push(nextId);
+    }
+    return nextId;
+  }
+  function resolveWorkspaceFallback(removedId) {
+    const remaining = list.value.filter((id) => id !== removedId);
+    if (remaining.length === 0) return null;
+    return remaining[remaining.length - 1] ?? remaining[0] ?? null;
+  }
+  function removeWorkspace(workspaceId) {
+    if (list.value.length <= 1) return false;
+    const idx = list.value.indexOf(workspaceId);
+    if (idx < 0) return false;
+    const fallback = resolveWorkspaceFallback(workspaceId);
+    list.value.splice(idx, 1);
+    if (active.value === workspaceId && fallback) {
+      active.value = fallback;
+    }
+    return true;
+  }
+  return {
+    list,
+    active,
+    overview,
+    workarea,
+    workspaceActiveIndex,
+    setWorkspace,
+    setOverview,
+    toggleOverview,
+    setWorkarea,
+    addWorkspace,
+    removeWorkspace,
+    resolveWorkspaceFallback
+  };
+});

package/dist/runtime/stores/storeNotification.d.ts

@@ -0,0 +1,27 @@
+import type { DesktopNotificationItem } from '../../types/index.js';
+export declare const useDesktopNotificationStore: import("pinia").SetupStoreDefinition<"desktop/notification", {
+    list: import("vue").Ref<any, any>;
+    add: (payload: {
+        title: string;
+        body?: string;
+        icon?: string;
+        appId?: string;
+    }) => DesktopNotificationItem;
+    remove: (id: string) => void;
+    clear: () => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+}>;
+export declare const useNotificationStore: import("pinia").SetupStoreDefinition<"desktop/notification", {
+    list: import("vue").Ref<any, any>;
+    add: (payload: {
+        title: string;
+        body?: string;
+        icon?: string;
+        appId?: string;
+    }) => DesktopNotificationItem;
+    remove: (id: string) => void;
+    clear: () => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+}>;

package/dist/runtime/stores/storeNotification.js

@@ -0,0 +1,55 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+import { useDesktopIPC } from "../composables/useDesktopIPC.js";
+let notificationCounter = 0;
+export const useDesktopNotificationStore = defineStore(
+  "desktop/notification",
+  () => {
+    const list = ref([]);
+    function add(payload) {
+      notificationCounter += 1;
+      const item = {
+        id: `notif-${Date.now()}-${notificationCounter}`,
+        title: payload.title,
+        body: payload.body,
+        icon: payload.icon,
+        appId: payload.appId,
+        timestamp: Date.now(),
+        read: false
+      };
+      list.value = [item, ...list.value.slice(0, 99)];
+      useDesktopIPC().emit(
+        "notification:added",
+        { id: item.id, title: item.title, appId: item.appId },
+        { source: payload.appId || "notification-store", severity: "info" }
+      );
+      return item;
+    }
+    function remove(id) {
+      list.value = list.value.filter((item) => item.id !== id);
+    }
+    function clear() {
+      list.value = [];
+    }
+    function markAsRead(id) {
+      const target = list.value.find((item) => item.id === id);
+      if (target) {
+        target.read = true;
+      }
+    }
+    function markAllAsRead() {
+      for (const item of list.value) {
+        item.read = true;
+      }
+    }
+    return {
+      list,
+      add,
+      remove,
+      clear,
+      markAsRead,
+      markAllAsRead
+    };
+  }
+);
+export const useNotificationStore = useDesktopNotificationStore;

package/dist/runtime/types/index.d.ts

@@ -0,0 +1 @@
+export * from '../../types/index.js';

package/dist/runtime/types/index.js

@@ -0,0 +1 @@
+export * from "../../types";

package/dist/runtime/utils/defineDesktopApp.d.ts

@@ -0,0 +1,2 @@
+import type { ApplicationConfig, IApplicationController } from '../../types/index.js';
+export declare function defineDesktopApp(config: ApplicationConfig): Promise<IApplicationController | undefined>;

package/dist/runtime/utils/defineDesktopApp.js

@@ -0,0 +1,5 @@
+import { useDesktopApplicationDefine } from "../composables/application/useDesktopApplicationDefine.js";
+export async function defineDesktopApp(config) {
+  const { define } = useDesktopApplicationDefine();
+  return define(config.id, config);
+}

package/dist/runtime/utils/defineDesktopPlugin.d.ts

@@ -0,0 +1,19 @@
+import { useDesktop, registerDesktopExtension } from '../composables/useDesktop.js';
+import { useDesktopHooks } from '../composables/useDesktopHooks.js';
+import { useDesktopIPC } from '../composables/useDesktopIPC.js';
+import { useDesktopCommands } from '../composables/useDesktopCommands.js';
+import { useDesktopApplication } from '../composables/useDesktopApplication.js';
+import { useDesktopWindow } from '../composables/window/useDesktopWindow.js';
+import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace.js';
+export interface DesktopPluginContext {
+    desktop: ReturnType<typeof useDesktop>;
+    hooks: ReturnType<typeof useDesktopHooks>;
+    ipc: ReturnType<typeof useDesktopIPC>;
+    commands: ReturnType<typeof useDesktopCommands>;
+    applications: ReturnType<typeof useDesktopApplication>;
+    windows: ReturnType<typeof useDesktopWindow>;
+    workspace: ReturnType<typeof useDesktopWorkspaceStore>;
+    services: ReturnType<typeof useDesktop>['services'];
+    registerExtension: typeof registerDesktopExtension;
+}
+export declare function defineDesktopPlugin(setup: (ctx: DesktopPluginContext) => void | Promise<void>): import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;

package/dist/runtime/utils/defineDesktopPlugin.js

@@ -0,0 +1,29 @@
+import { defineNuxtPlugin } from "nuxt/app";
+import { useDesktop, registerDesktopExtension } from "../composables/useDesktop.js";
+import { useDesktopHooks } from "../composables/useDesktopHooks.js";
+import { useDesktopIPC } from "../composables/useDesktopIPC.js";
+import { useDesktopCommands } from "../composables/useDesktopCommands.js";
+import { useDesktopApplication } from "../composables/useDesktopApplication.js";
+import { useDesktopWindow } from "../composables/window/useDesktopWindow.js";
+import { useDesktopWorkspaceStore } from "../stores/storeDesktopWorkspace.js";
+export function defineDesktopPlugin(setup) {
+  return defineNuxtPlugin({
+    dependsOn: ["pinia", "desktop-shell-init"],
+    async setup() {
+      if (import.meta.server) return;
+      const desktop = useDesktop();
+      const ctx = {
+        desktop,
+        hooks: useDesktopHooks(),
+        ipc: useDesktopIPC(),
+        commands: useDesktopCommands(),
+        applications: useDesktopApplication(),
+        windows: useDesktopWindow(),
+        workspace: useDesktopWorkspaceStore(),
+        services: desktop.services,
+        registerExtension: registerDesktopExtension
+      };
+      await setup(ctx);
+    }
+  });
+}

package/dist/runtime/utils/utilApp.d.ts

@@ -0,0 +1,2 @@
+import type { ApplicationConfig } from '../../types/index.js';
+export declare function normalizeApplicationConfig(config: ApplicationConfig): ApplicationConfig;

package/dist/runtime/utils/utilApp.js

@@ -0,0 +1,9 @@
+export function normalizeApplicationConfig(config) {
+  return {
+    ...config,
+    entries: config.entries ?? {},
+    windows: config.windows ?? {},
+    commands: config.commands ?? {},
+    terminal: config.terminal ?? {}
+  };
+}

package/dist/runtime/utils/utilCaptureElementToCanvas.d.ts

@@ -0,0 +1 @@
+export declare function captureElementToCanvas(element: HTMLElement | null | undefined, _options?: Record<string, unknown>): Promise<HTMLCanvasElement | null>;

package/dist/runtime/utils/utilCaptureElementToCanvas.js

@@ -0,0 +1,21 @@
+export async function captureElementToCanvas(element, _options) {
+  if (!element || typeof document === "undefined") {
+    return null;
+  }
+  try {
+    const rect = element.getBoundingClientRect();
+    const width = Math.max(1, Math.round(rect.width || element.clientWidth || 320));
+    const height = Math.max(1, Math.round(rect.height || element.clientHeight || 200));
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (ctx) {
+      ctx.fillStyle = "#0f172a";
+      ctx.fillRect(0, 0, width, height);
+    }
+    return canvas;
+  } catch {
+    return null;
+  }
+}

package/dist/runtime/utils/utilDebug.d.ts

@@ -0,0 +1,4 @@
+export declare function isDebugMode(): boolean;
+export declare function debugLog(...args: unknown[]): void;
+export declare function debugWarn(...args: unknown[]): void;
+export declare function debugError(...args: unknown[]): void;

package/dist/runtime/utils/utilDebug.js

@@ -0,0 +1,24 @@
+import { useRuntimeConfig } from "nuxt/app";
+export function isDebugMode() {
+  try {
+    const config = useRuntimeConfig();
+    return Boolean(config.public.desktop?.debug);
+  } catch {
+    return false;
+  }
+}
+export function debugLog(...args) {
+  if (isDebugMode()) {
+    console.debug("[@owdproject/nuxt]", ...args);
+  }
+}
+export function debugWarn(...args) {
+  if (isDebugMode()) {
+    console.warn("[@owdproject/nuxt]", ...args);
+  }
+}
+export function debugError(...args) {
+  if (isDebugMode()) {
+    console.error("[@owdproject/nuxt]", ...args);
+  }
+}

package/dist/runtime/utils/utilDetectSnapZone.d.ts

@@ -0,0 +1 @@
+export { detectSnapZone, WINDOW_SNAP_EDGE_PX, WORKSPACE_EDGE_DROP_PX, type SnapZoneHint, type DetectSnapZoneOptions, } from '@owdproject/core';

package/dist/runtime/utils/utilDetectSnapZone.js

@@ -0,0 +1,5 @@
+export {
+  detectSnapZone,
+  WINDOW_SNAP_EDGE_PX,
+  WORKSPACE_EDGE_DROP_PX
+} from "@owdproject/core";

package/dist/runtime/utils/utilWindowControllerAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { IWindowController } from '../../types/index.js';
+export declare function handleWindowControllerProps(windowProp?: IWindowController): IWindowController;

package/dist/runtime/utils/utilWindowControllerAdapter.js

@@ -0,0 +1,151 @@
+import { reactive } from "vue";
+export function handleWindowControllerProps(windowProp) {
+  if (windowProp) {
+    return windowProp;
+  }
+  const state = reactive({
+    id: "standalone-window",
+    createdAt: Date.now(),
+    workspace: "workspace-1",
+    position: { x: 80, y: 80, z: 10 },
+    size: { width: 420, height: 320 },
+    focused: true,
+    active: true,
+    maximized: false,
+    minimizable: true,
+    maximizable: true,
+    destroyable: true,
+    draggable: true,
+    resizable: true,
+    dragging: false,
+    resizing: false,
+    layout: "normal"
+  });
+  const fallback = {
+    application: void 0,
+    instanced: false,
+    model: "standalone",
+    stateValue: "normal.focused.idle",
+    config: {
+      title: "Window",
+      size: { width: 420, height: 320 },
+      position: { x: 80, y: 80, z: 10 }
+    },
+    override: {},
+    state,
+    meta: {},
+    title: "Window",
+    windowTitle: "Window",
+    icon: void 0,
+    size: state.size,
+    position: state.position,
+    isMinimizable: true,
+    isMaximizable: true,
+    isMaximized: false,
+    isDestroyable: true,
+    isDraggable: true,
+    isResizable: true,
+    menu: [],
+    setMenu() {
+    },
+    dispose() {
+    },
+    destroy() {
+      return false;
+    },
+    startDrag() {
+      state.dragging = true;
+    },
+    stopDrag() {
+      state.dragging = false;
+    },
+    startResize() {
+      state.resizing = true;
+    },
+    stopResize() {
+      state.resizing = false;
+    },
+    actions: {
+      setActive(v) {
+        state.active = v;
+      },
+      setFocus(v) {
+        state.focused = v;
+      },
+      bringToFront() {
+        state.focused = true;
+      },
+      focus() {
+        state.focused = true;
+      },
+      setPosition(pos) {
+        state.position.x = pos.x;
+        state.position.y = pos.y;
+      },
+      startDrag() {
+        state.dragging = true;
+      },
+      stopDrag() {
+        state.dragging = false;
+      },
+      startResize() {
+        state.resizing = true;
+      },
+      stopResize() {
+        state.resizing = false;
+      },
+      setSize(sz) {
+        state.size.width = sz.width;
+        state.size.height = sz.height;
+      },
+      minimize() {
+        state.active = false;
+        return true;
+      },
+      unminimize() {
+        state.active = true;
+        return true;
+      },
+      toggleMinimize() {
+        state.active = !state.active;
+      },
+      toggleMaximize() {
+        state.maximized = !state.maximized;
+        return true;
+      },
+      maximize() {
+        state.maximized = true;
+        return true;
+      },
+      unmaximize() {
+        state.maximized = false;
+        return true;
+      },
+      setLayout(layout) {
+        state.layout = layout;
+        return true;
+      },
+      clearLayout() {
+        state.layout = "normal";
+        return true;
+      },
+      saveBoundsBeforeLayout() {
+      },
+      destroy() {
+        return false;
+      },
+      setWorkspace(ws) {
+        state.workspace = ws;
+      },
+      setTitleOverride() {
+      },
+      resetTitleOverride() {
+      },
+      setWindowTitleOverride() {
+      },
+      resetWindowTitleOverride() {
+      }
+    }
+  };
+  return fallback;
+}

package/dist/runtime/utils/utilWindowLayout.d.ts

@@ -0,0 +1,4 @@
+import { computeSnapRect, workareaBottom, workareaRight, type DesktopWorkareaRect, type SnapZoneHint, type WindowBounds, type WindowLayout } from '@owdproject/core';
+import type { IWindowController } from '../../types/index.js';
+export { computeSnapRect, workareaBottom, workareaRight, type DesktopWorkareaRect, type WindowBounds, type WindowLayout, };
+export declare function applySnapToWindow(win: IWindowController, zone: SnapZoneHint, workarea: DesktopWorkareaRect): boolean;

package/dist/runtime/utils/utilWindowLayout.js

@@ -0,0 +1,34 @@
+import {
+  computeSnapRect,
+  workareaBottom,
+  workareaRight
+} from "@owdproject/core";
+import { useDesktopHooks } from "../composables/useDesktopHooks.js";
+import { useDesktopIPC } from "../composables/useDesktopIPC.js";
+export {
+  computeSnapRect,
+  workareaBottom,
+  workareaRight
+};
+export function applySnapToWindow(win, zone, workarea) {
+  if (!win.isMaximizable) return false;
+  if (workarea.width <= 0 || workarea.height <= 0) return false;
+  const rect = computeSnapRect(zone, workarea);
+  win.actions.setLayout(zone);
+  win.actions.setPosition({ x: rect.x, y: rect.y });
+  win.actions.setSize({ width: rect.width, height: rect.height });
+  void useDesktopHooks().callHook("window:layout-change", {
+    window: win,
+    layout: zone
+  });
+  useDesktopIPC().emit(
+    "window:layout-change",
+    {
+      windowId: win.state.id,
+      title: win.title,
+      layout: zone
+    },
+    { source: "display-server", severity: "info" }
+  );
+  return true;
+}

package/dist/runtime/utils/utilWorkspaceWindows.d.ts

@@ -0,0 +1,2 @@
+import type { IApplicationController, IWindowController } from '../../types/index.js';
+export declare function collectWindowsOnWorkspace(appsIterable: Iterable<IApplicationController>, workspaceId: string, activeWorkspaceId: string): IWindowController[];

package/dist/runtime/utils/utilWorkspaceWindows.js

@@ -0,0 +1,12 @@
+export function collectWindowsOnWorkspace(appsIterable, workspaceId, activeWorkspaceId) {
+  const result = [];
+  for (const app of appsIterable) {
+    for (const win of app.windows.values()) {
+      const ws = win.state.workspace || activeWorkspaceId;
+      if (ws === workspaceId) {
+        result.push(win);
+      }
+    }
+  }
+  return result;
+}