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

package/dist/runtime/components/window/DesktopCoreWindowSnapHintsBase.vue

@@ -0,0 +1,46 @@
+<script setup>
+import { computed } from "vue";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace";
+import { useDesktopWindowSnapDrop } from "../../composables/window/useDesktopWindowSnapDrop";
+const props = defineProps({
+  enabled: { type: Boolean, required: false }
+});
+const desktopWorkspaceStore = useDesktopWorkspaceStore();
+const { snapHint, snapHintRect, isSnapDragActive } = useDesktopWindowSnapDrop();
+const visible = computed(
+  () => props.enabled !== false && !desktopWorkspaceStore.overview && isSnapDragActive.value && snapHint.value !== null && snapHintRect.value !== null
+);
+const hintStyle = computed(() => {
+  const rect = snapHintRect.value;
+  if (!rect) return void 0;
+  return {
+    left: `${rect.x}px`,
+    top: `${rect.y}px`,
+    width: `${rect.width}px`,
+    height: `${rect.height}px`
+  };
+});
+</script>
+
+<template>
+  <div
+    v-if="visible"
+    class="desktop-window-snap-hints"
+    aria-hidden="true"
+  >
+    <div
+      class="desktop-window-snap-hints__zone"
+      :class="`desktop-window-snap-hints__zone--${snapHint}`"
+      :style="hintStyle"
+    >
+      <slot
+        :zone="snapHint"
+        :rect="snapHintRect"
+      />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.desktop-window-snap-hints{inset:0;pointer-events:none;position:fixed;z-index:999998}.desktop-window-snap-hints__zone{background:rgba(96,165,250,.18);border:2px solid rgba(96,165,250,.85);border-radius:4px;box-sizing:border-box;position:fixed;transition:left 80ms ease,top 80ms ease,width 80ms ease,height 80ms ease}
+</style>

package/dist/runtime/components/window/DesktopCoreWindowSnapHintsBase.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    enabled?: boolean;
+};
+declare var __VLS_1: {
+    zone: any;
+    rect: import("@owdproject/core").WindowBounds | null;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/workspace/DesktopCoreWorkspaceEdgeHintsBase.d.vue.ts

@@ -0,0 +1,24 @@
+type __VLS_Props = {
+    enabled?: boolean;
+};
+declare var __VLS_1: {
+    desktopIndex: number | null;
+    side: "left";
+}, __VLS_3: {
+    desktopIndex: number | null;
+    side: "right";
+};
+type __VLS_Slots = {} & {
+    left?: (props: typeof __VLS_1) => any;
+} & {
+    right?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/workspace/DesktopCoreWorkspaceEdgeHintsBase.vue

@@ -0,0 +1,50 @@
+<script setup>
+import { computed } from "vue";
+import { useDesktopWorkspaceEdgeDrop } from "../../composables/workspace/useDesktopWorkspaceEdgeDrop";
+import { useDesktopWorkspaceStore } from "../../stores/storeDesktopWorkspace";
+const props = defineProps({
+  enabled: { type: Boolean, required: false }
+});
+const desktopWorkspaceStore = useDesktopWorkspaceStore();
+const { edgeHint, edgeTargetDesktopIndex } = useDesktopWorkspaceEdgeDrop();
+const visible = computed(
+  () => props.enabled !== false && !desktopWorkspaceStore.overview && desktopWorkspaceStore.list.length > 1 && edgeHint.value !== null && edgeTargetDesktopIndex.value !== null
+);
+</script>
+
+<template>
+  <div
+    v-if="visible"
+    class="desktop-workspace-edge-hints"
+    aria-hidden="true"
+  >
+    <div
+      class="desktop-workspace-edge-hints__zone desktop-workspace-edge-hints__zone--left"
+      :class="{
+  'desktop-workspace-edge-hints__zone--active': edgeHint === 'left'
+}"
+    >
+      <slot
+        name="left"
+        :desktop-index="edgeTargetDesktopIndex"
+        :side="'left'"
+      />
+    </div>
+    <div
+      class="desktop-workspace-edge-hints__zone desktop-workspace-edge-hints__zone--right"
+      :class="{
+  'desktop-workspace-edge-hints__zone--active': edgeHint === 'right'
+}"
+    >
+      <slot
+        name="right"
+        :desktop-index="edgeTargetDesktopIndex"
+        :side="'right'"
+      />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.desktop-workspace-edge-hints{inset:0;pointer-events:none;position:fixed;z-index:999998}.desktop-workspace-edge-hints__zone{bottom:0;opacity:0;position:fixed;top:0;transition:opacity .12s ease;width:72px}.desktop-top-workspace-edge-hints__zone--left{left:0}.desktop-workspace-edge-hints__zone--right{right:0}.desktop-workspace-edge-hints__zone--active{opacity:1}
+</style>

package/dist/runtime/components/workspace/DesktopCoreWorkspaceEdgeHintsBase.vue.d.ts

@@ -0,0 +1,24 @@
+type __VLS_Props = {
+    enabled?: boolean;
+};
+declare var __VLS_1: {
+    desktopIndex: number | null;
+    side: "left";
+}, __VLS_3: {
+    desktopIndex: number | null;
+    side: "right";
+};
+type __VLS_Slots = {} & {
+    left?: (props: typeof __VLS_1) => any;
+} & {
+    right?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/composables/application/state.d.ts

@@ -0,0 +1 @@
+export declare const apps: import("vue").Reactive<Map<string, IApplicationController>>;

package/dist/runtime/composables/application/state.js

@@ -0,0 +1,2 @@
+import { reactive } from "vue";
+export const apps = reactive(/* @__PURE__ */ new Map());

package/dist/runtime/composables/application/useDesktopApplicationDefine.d.ts

@@ -0,0 +1,4 @@
+export declare function useDesktopApplicationDefine(): {
+    define: (id: string, config: ApplicationConfig) => Promise<any>;
+    defineApp: (id: string, config: ApplicationConfig) => Promise<any>;
+};

package/dist/runtime/composables/application/useDesktopApplicationDefine.js

@@ -0,0 +1,36 @@
+import { markRaw } from "vue";
+import { ApplicationController } from "../../internal/controllers/ApplicationController.js";
+import { normalizeApplicationConfig } from "../../utils/utilApp.js";
+import { debugLog } from "../../utils/utilDebug.js";
+import { useDesktopHooks } from "../useDesktopHooks.js";
+import { apps } from "./state.js";
+export function useDesktopApplicationDefine() {
+  async function define(id, config) {
+    if (apps.has(id)) {
+      debugLog(`App "${id}" is already defined`);
+      return apps.get(id);
+    }
+    const { callHook } = useDesktopHooks();
+    const defineCtx = {
+      id,
+      config,
+      cancel: false
+    };
+    await callHook("app:before-define", defineCtx);
+    if (defineCtx.cancel) {
+      return void 0;
+    }
+    const normalizedConfig = normalizeApplicationConfig(defineCtx.config);
+    const applicationConfig = markRaw(normalizedConfig);
+    const applicationController = new ApplicationController(defineCtx.id, applicationConfig);
+    await applicationController.initApplication();
+    const rawController = markRaw(applicationController);
+    apps.set(defineCtx.id, rawController);
+    await callHook("app:defined", { app: rawController });
+    return rawController;
+  }
+  return {
+    define,
+    defineApp: define
+  };
+}

package/dist/runtime/composables/application/useDesktopApplicationExec.d.ts

@@ -0,0 +1,3 @@
+export declare function useDesktopApplicationExec(): {
+    exec: (id: string, rawCommand: string) => Promise<CommandOutput>;
+};

package/dist/runtime/composables/application/useDesktopApplicationExec.js

@@ -0,0 +1,26 @@
+import * as shellwords from "shellwords";
+import getopts from "getopts";
+import { apps } from "./state.js";
+export function useDesktopApplicationExec() {
+  async function exec(id, rawCommand) {
+    const app = apps.get(id);
+    if (!app) {
+      throw Error(`App "${id}" is not defined`);
+    }
+    const args = shellwords.split(rawCommand);
+    const parsed = getopts(args);
+    const command = parsed._[0];
+    if (!app.config.commands || !Object.prototype.hasOwnProperty.call(app.config.commands, command)) {
+      throw Error(
+        `App command "${command}" is not defined in ${id} application`
+      );
+    }
+    const commandFn = app.config.commands[command];
+    const commandOutput = await commandFn(app, parsed);
+    app.setRunning(true);
+    return commandOutput;
+  }
+  return {
+    exec
+  };
+}

package/dist/runtime/composables/application/useDesktopApplicationProcess.d.ts

@@ -0,0 +1,24 @@
+export declare function useDesktopApplicationProcess(): {
+    running: import("vue").ComputedRef<IApplicationController[]>;
+    processes: import("vue").ComputedRef<{
+        id: string;
+        title: string;
+        icon?: string;
+        category?: string;
+        pid: number | null;
+        state: string;
+        isRunning: boolean;
+        isSuspended: boolean;
+        windowCount: number;
+        startedAt: number | null;
+        controller: IApplicationController;
+    }[]>;
+    isRunning: (id: string | undefined) => boolean;
+    findByPid: (pid: number) => IApplicationController | undefined;
+    resolveApp: (idOrPid: string | number) => IApplicationController | undefined;
+    launch: (id: string, entryKey?: string, argument?: string) => Promise<any>;
+    suspend: (idOrPid: string | number) => boolean;
+    resume: (idOrPid: string | number) => boolean;
+    kill: (idOrPid: string | number, signal?: "SIGTERM" | "SIGKILL" | "SIGSTOP" | "SIGCONT") => boolean;
+    close: (id: string) => void;
+};

package/dist/runtime/composables/application/useDesktopApplicationProcess.js

@@ -0,0 +1,140 @@
+import { computed } from "vue";
+import { apps } from "./state.js";
+import { useDesktopApplicationExec } from "./useDesktopApplicationExec.js";
+import { useDesktopHooks } from "../useDesktopHooks.js";
+const sharedRunningApps = computed(() => {
+  const runningApps = [];
+  for (const app of apps.values()) {
+    const openCount = app.openWindowCount.value;
+    if (app.isRunning || openCount > 0) {
+      runningApps.push(app);
+    }
+  }
+  return runningApps;
+});
+const sharedProcesses = computed(() => {
+  const allProcesses = [];
+  for (const app of apps.values()) {
+    allProcesses.push({
+      id: app.id,
+      title: app.config.title,
+      icon: app.config.icon,
+      category: app.config.category,
+      pid: app.pid,
+      state: app.stateValue,
+      isRunning: app.isRunning,
+      isSuspended: app.isSuspended,
+      windowCount: app.openWindowCount.value,
+      startedAt: app.startedAt,
+      controller: app
+    });
+  }
+  return allProcesses.sort((a, b) => {
+    if (a.isRunning !== b.isRunning) return a.isRunning ? -1 : 1;
+    return (a.pid ?? 99999) - (b.pid ?? 99999);
+  });
+});
+export function useDesktopApplicationProcess() {
+  const { exec } = useDesktopApplicationExec();
+  function isRunning(id) {
+    if (!id) return false;
+    const app = apps.get(id);
+    return !!app?.isRunning;
+  }
+  function findByPid(pid) {
+    for (const app of apps.values()) {
+      if (app.pid === pid) {
+        return app;
+      }
+    }
+    return void 0;
+  }
+  function resolveApp(idOrPid) {
+    if (typeof idOrPid === "number") {
+      return findByPid(idOrPid);
+    }
+    const asNumber = Number(idOrPid);
+    if (!Number.isNaN(asNumber) && String(asNumber) === idOrPid.trim()) {
+      const byPid = findByPid(asNumber);
+      if (byPid) return byPid;
+    }
+    if (apps.has(idOrPid)) {
+      return apps.get(idOrPid);
+    }
+    const lower = idOrPid.toLowerCase();
+    for (const app of apps.values()) {
+      if (app.id.toLowerCase() === lower || app.id.toLowerCase().endsWith(`.${lower}`) || app.config.title.toLowerCase() === lower) {
+        return app;
+      }
+    }
+    return void 0;
+  }
+  async function launch(id, entryKey, argument = "") {
+    const app = resolveApp(id);
+    if (!app) {
+      throw Error(`App "${id}" is not defined`);
+    }
+    const { callHook } = useDesktopHooks();
+    const beforeLaunchCtx = {
+      app,
+      entryKey,
+      argument,
+      cancel: false
+    };
+    await callHook("app:before-launch", beforeLaunchCtx);
+    if (beforeLaunchCtx.cancel) {
+      return;
+    }
+    const entries = app.config.entries || {};
+    const resolvedKey = beforeLaunchCtx.entryKey || Object.keys(entries)[0];
+    if (!resolvedKey || !entries.hasOwnProperty(resolvedKey)) {
+      if (app.config.windows && Object.keys(app.config.windows).length > 0) {
+        const firstModel = Object.keys(app.config.windows)[0];
+        return app.openWindow(firstModel);
+      }
+      throw Error(`App entry "${resolvedKey}" is not defined in ${app.id} application`);
+    }
+    const entry = entries[resolvedKey];
+    const finalArg = beforeLaunchCtx.argument ?? argument;
+    const suffix = finalArg ? ` ${finalArg}` : "";
+    await exec(app.id, entry.command + suffix);
+  }
+  function suspend(idOrPid) {
+    const app = resolveApp(idOrPid);
+    if (!app || !app.isRunning) return false;
+    app.suspend();
+    return true;
+  }
+  function resume(idOrPid) {
+    const app = resolveApp(idOrPid);
+    if (!app || !app.isRunning) return false;
+    app.resume();
+    return true;
+  }
+  function kill(idOrPid, signal = "SIGTERM") {
+    const app = resolveApp(idOrPid);
+    if (!app) return false;
+    app.sendSignal(signal);
+    return true;
+  }
+  function close(id) {
+    const app = resolveApp(id);
+    if (!app) {
+      throw Error(`App "${id}" is not defined`);
+    }
+    app.closeAllWindows();
+    app.setRunning(false);
+  }
+  return {
+    running: sharedRunningApps,
+    processes: sharedProcesses,
+    isRunning,
+    findByPid,
+    resolveApp,
+    launch,
+    suspend,
+    resume,
+    kill,
+    close
+  };
+}

package/dist/runtime/composables/application/useDesktopApplicationRegistry.d.ts

@@ -0,0 +1,11 @@
+import { type ComputedRef } from 'vue';
+export type SortBy = 'title' | 'category' | ((a: any, b: any) => number);
+export type Visibility = 'primary' | 'all' | ((entry: any) => boolean);
+export declare function useDesktopApplicationRegistry(): {
+    list: ComputedRef<any[]>;
+    categories: ComputedRef<Record<string, IApplicationController[]>>;
+    apps: import("vue").Reactive<Map<string, IApplicationController>>;
+    get: (id: string) => any;
+    isAppDefined: (id: string) => boolean;
+    getSortedEntries: (sortBy?: SortBy, visibility?: Visibility) => ComputedRef<any[]>;
+};

package/dist/runtime/composables/application/useDesktopApplicationRegistry.js

@@ -0,0 +1,60 @@
+import { computed } from "vue";
+import { apps } from "./state.js";
+const sharedRegistryList = computed(() => {
+  const entries = [];
+  for (const app of apps.values()) {
+    if (!app.config.entries) {
+      continue;
+    }
+    for (const entryKey of Object.keys(app.config.entries)) {
+      const entry = app.config.entries[entryKey];
+      entries.push({
+        application: app,
+        title: entry.title ?? app.config.title,
+        icon: entry.icon ?? app.config.icon,
+        category: entry.category ?? app.config.category,
+        visibility: entry.visibility ?? "primary",
+        command: entry.command
+      });
+    }
+  }
+  return entries;
+});
+const sharedCategories = computed(() => {
+  const categorizedApps = {};
+  for (const app of apps.values()) {
+    const category = app.config.category || "other";
+    if (!categorizedApps[category]) {
+      categorizedApps[category] = [];
+    }
+    categorizedApps[category].push(app);
+  }
+  for (const category in categorizedApps) {
+    categorizedApps[category].sort(
+      (a, b) => a.config.title.localeCompare(b.config.title)
+    );
+  }
+  return categorizedApps;
+});
+export function useDesktopApplicationRegistry() {
+  function getSortedEntries(sortBy = "title", visibility = "primary") {
+    return computed(() => {
+      const currentEntries = [...sharedRegistryList.value];
+      const filtered = typeof visibility === "function" ? currentEntries.filter(visibility) : visibility === "primary" ? currentEntries.filter((e) => e.visibility !== "secondary") : currentEntries;
+      const sorted = typeof sortBy === "function" ? filtered.sort(sortBy) : sortBy === "title" ? filtered.sort(
+        (a, b) => (a.title || "").localeCompare(b.title || "")
+      ) : filtered.sort(
+        (a, b) => (a.category || "").localeCompare(b.category || "")
+      );
+      return sorted;
+    });
+  }
+  return {
+    list: sharedRegistryList,
+    categories: sharedCategories,
+    apps,
+    get: (id) => apps.get(id),
+    isAppDefined: (id) => apps.has(id),
+    getSortedEntries
+  };
+}

package/dist/runtime/composables/useApplicationEntries.d.ts

@@ -0,0 +1,5 @@
+import { type Ref } from 'vue';
+import { type SortBy, type Visibility } from './application/useDesktopApplicationRegistry.js';
+export declare function useApplicationEntries(): {
+    sortedAppEntries: (sortBy?: SortBy, visibility?: Visibility) => Ref<any[]>;
+};

package/dist/runtime/composables/useApplicationEntries.js

@@ -0,0 +1,10 @@
+import {
+  useDesktopApplicationRegistry
+} from "./application/useDesktopApplicationRegistry.js";
+export function useApplicationEntries() {
+  const registry = useDesktopApplicationRegistry();
+  const sortedAppEntries = function(sortBy = "title", visibility = "primary") {
+    return registry.getSortedEntries(sortBy, visibility);
+  };
+  return { sortedAppEntries };
+}

package/dist/runtime/composables/useApplicationManager.d.ts

@@ -0,0 +1,16 @@
+export declare function useApplicationManager(): {
+    defineApp: (id: string, config: ApplicationConfig) => Promise<any>;
+    isAppDefined: (id: string) => boolean;
+    getAppById: (id: string) => any;
+    isAppRunning: (id: string | undefined) => boolean;
+    launchAppEntry: (id: string, entryKey?: string, argument?: string) => Promise<any>;
+    execAppCommand: (id: string, rawCommand: string) => Promise<CommandOutput>;
+    closeApp: (id: string) => void;
+    getWindowOpenedId: (windowId: string) => IWindowController | undefined;
+    apps: import("vue").Reactive<Map<string, IApplicationController>>;
+    appsEntries: import("vue").ComputedRef<any[]>;
+    appsRunning: import("vue").ComputedRef<IApplicationController[]>;
+    windowsOpened: import("vue").ComputedRef<Map<string, IWindowController>>;
+    appCategories: import("vue").ComputedRef<string[]>;
+    appsByCategory: import("vue").ComputedRef<Record<string, IApplicationController[]>>;
+};

package/dist/runtime/composables/useApplicationManager.js

@@ -0,0 +1,30 @@
+import { computed } from "vue";
+import { apps } from "./application/state.js";
+import { useDesktopApplicationProcess } from "./application/useDesktopApplicationProcess.js";
+import { useDesktopApplicationExec } from "./application/useDesktopApplicationExec.js";
+import { useDesktopApplicationDefine } from "./application/useDesktopApplicationDefine.js";
+import { useDesktopApplicationRegistry } from "./application/useDesktopApplicationRegistry.js";
+import { useDesktopWindow } from "./window/useDesktopWindow.js";
+export function useApplicationManager() {
+  const process = useDesktopApplicationProcess();
+  const exec = useDesktopApplicationExec();
+  const define = useDesktopApplicationDefine();
+  const registry = useDesktopApplicationRegistry();
+  const windowService = useDesktopWindow();
+  return {
+    defineApp: define.defineApp,
+    isAppDefined: (id) => apps.has(id),
+    getAppById: (id) => apps.get(id),
+    isAppRunning: process.isRunning,
+    launchAppEntry: process.launch,
+    execAppCommand: exec.exec,
+    closeApp: process.close,
+    getWindowOpenedId: windowService.get,
+    apps,
+    appsEntries: registry.list,
+    appsRunning: process.running,
+    windowsOpened: windowService.index,
+    appCategories: computed(() => Object.keys(registry.categories.value)),
+    appsByCategory: registry.categories
+  };
+}

package/dist/runtime/composables/useBlockNonInputContextMenu.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Blocks the browser context menu on non-input elements (typical desktop shell behaviour).
+ * Debug builds skip blocking so DevTools stay usable when {@link isDebugMode} is true.
+ */
+export declare function useBlockNonInputContextMenu(): void;

package/dist/runtime/composables/useBlockNonInputContextMenu.js

@@ -0,0 +1,19 @@
+import { useEventListener } from "@vueuse/core";
+import { isDebugMode } from "../utils/utilDebug.js";
+export function useBlockNonInputContextMenu() {
+  useEventListener(
+    document,
+    "contextmenu",
+    (event) => {
+      if (isDebugMode()) return;
+      const target = event.target;
+      if (!target) return;
+      const tag = target.tagName?.toLowerCase();
+      const isInput = tag === "input" || tag === "textarea" || Boolean(target.isContentEditable);
+      if (!isInput) {
+        event.preventDefault();
+      }
+    },
+    { passive: false }
+  );
+}