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

package/dist/runtime/stores/storeDesktopDefaultApps.js

@@ -0,0 +1,21 @@
+import { defineStore } from "pinia";
+import { useDesktopStore } from "./storeDesktop.js";
+export const useDesktopDefaultAppsStore = defineStore(
+  "desktop/default-apps",
+  () => {
+    const desktopStore = useDesktopStore();
+    function getDefaultApp(feature) {
+      return desktopStore.state.defaultApps[feature];
+    }
+    function setDefaultApp(feature, application, entry) {
+      desktopStore.state.defaultApps[feature] = {
+        applicationId: application.id,
+        entry
+      };
+    }
+    return {
+      getDefaultApp,
+      setDefaultApp
+    };
+  }
+);

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

@@ -0,0 +1,6 @@
+import type { DesktopTrayItem } from '../../types/index.js';
+export declare const useDesktopTrayStore: import("pinia").SetupStoreDefinition<"desktop/tray", {
+    items: import("vue").Ref<any, any>;
+    registerIcon: (item: DesktopTrayItem) => void;
+    unregisterIcon: (id: string) => void;
+}>;

package/dist/runtime/stores/storeDesktopTray.js

@@ -0,0 +1,21 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+export const useDesktopTrayStore = defineStore("desktop/tray", () => {
+  const items = ref([]);
+  function registerIcon(item) {
+    const existingIdx = items.value.findIndex((i) => i.id === item.id);
+    if (existingIdx >= 0) {
+      items.value[existingIdx] = item;
+    } else {
+      items.value.push(item);
+    }
+  }
+  function unregisterIcon(id) {
+    items.value = items.value.filter((i) => i.id !== id);
+  }
+  return {
+    items,
+    registerIcon,
+    unregisterIcon
+  };
+});

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

@@ -0,0 +1,4 @@
+export declare const useDesktopVolumeStore: import("pinia").SetupStoreDefinition<"desktop/volume", {
+    master: import("vue").Ref<number, number>;
+    setMasterVolume: (value: number) => void;
+}>;

package/dist/runtime/stores/storeDesktopVolume.js

@@ -0,0 +1,12 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+export const useDesktopVolumeStore = defineStore("desktop/volume", () => {
+  const master = ref(100);
+  function setMasterVolume(value) {
+    master.value = Math.max(0, Math.min(100, value));
+  }
+  return {
+    master,
+    setMasterVolume
+  };
+});

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

@@ -0,0 +1,26 @@
+import type { DesktopWorkareaRect } from '../../types/index.js';
+export declare const EMPTY_DESKTOP_WORKAREA: DesktopWorkareaRect;
+export declare const useDesktopWorkspaceStore: import("pinia").SetupStoreDefinition<"desktop/workspace", {
+    list: import("vue").Ref<string[], string[]>;
+    active: import("vue").Ref<string, string>;
+    overview: import("vue").Ref<boolean, boolean>;
+    workarea: import("vue").Ref<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, DesktopWorkareaRect | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    workspaceActiveIndex: import("vue").ComputedRef<number>;
+    setWorkspace: (workspaceId: string) => boolean;
+    setOverview: (value: boolean) => void;
+    toggleOverview: () => void;
+    setWorkarea: (rect: DesktopWorkareaRect) => void;
+    addWorkspace: (id?: string) => string;
+    removeWorkspace: (workspaceId: string) => boolean;
+    resolveWorkspaceFallback: (removedId: string) => string | null;
+}>;

package/dist/runtime/stores/storeDesktopWorkspace.js

@@ -0,0 +1,103 @@
+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
+    };
+  },
+  {
+    // Inert unless an optional persistence module registers the adapter.
+    // @ts-expect-error pinia-plugin-persistedstate-2 store option
+    persistedState: {
+      persist: true,
+      // `overview` and `workarea` are runtime-only.
+      includePaths: ["list", "active"]
+    }
+  }
+);

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,62 @@
+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
+    };
+  },
+  {
+    // Inert unless an optional persistence module registers the adapter.
+    // @ts-expect-error pinia-plugin-persistedstate-2 store option
+    persistedState: {
+      persist: true
+    }
+  }
+);
+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;
+}