@owdproject/core 3.1.4 → 3.2.0

package/runtime/composables/useApplicationManager.ts

@@ -29,7 +29,7 @@ export function useApplicationManager() {
     const applicationController: IApplicationController = new ApplicationController(id, applicationConfig)
     await applicationController.initApplication()
 
-    apps.set(id, applicationController)
+    apps.set(id, markRaw(applicationController))
 
     return applicationController
   }
@@ -184,11 +184,18 @@ export function useApplicationManager() {
    * Array of opened windows for system bars, docks
    */
   const windowsOpened = computed(() => {
-    const windows: Map<string, IWindowController>[] = []
+    const windows = new Map<string, IWindowController>()
 
     for (const applicationController of apps.values()) {
-      if (applicationController.isRunning) {
-        windows.push(...applicationController.windows)
+      if (
+        !applicationController.isRunning &&
+        applicationController.openWindowCount.value === 0
+      ) {
+        continue
+      }
+
+      for (const [windowId, window] of applicationController.windows) {
+        windows.set(windowId, window)
       }
     }
 
@@ -202,7 +209,8 @@ export function useApplicationManager() {
     const runningApps: IApplicationController[] = []
 
     for (const applicationController of apps.values()) {
-      if (applicationController.isRunning) {
+      const openCount = applicationController.openWindowCount.value
+      if (applicationController.isRunning || openCount > 0) {
         runningApps.push(applicationController)
       }
     }
@@ -211,13 +219,10 @@ export function useApplicationManager() {
   })
 
   function getWindowOpenedId(windowId: string) {
-    const mapWindowFound = windowsOpened.value.find((window: any) => {
-      return window[1].state.id === windowId
-    })
-
-    if (mapWindowFound) {
-      // @ts-ignore
-      return mapWindowFound[1] as IWindowController
+    for (const window of windowsOpened.value.values()) {
+      if (window.state.id === windowId) {
+        return window
+      }
     }
   }
 
@@ -262,7 +267,6 @@ export function useApplicationManager() {
   })
 
   return {
-    apps,
     defineApp,
     isAppDefined,
     getAppById,
@@ -271,6 +275,7 @@ export function useApplicationManager() {
     execAppCommand,
     closeApp,
     getWindowOpenedId,
+    apps,
     appsEntries,
     appsRunning,
     windowsOpened,

package/runtime/composables/useDesktopManager.ts

@@ -1,25 +1,49 @@
-import { deepMerge } from '../utils/utilCommon'
+import { computed } from 'vue'
 import { useAppConfig } from 'nuxt/app'
+import { deepMerge } from '../utils/utilCommon'
+import { useDesktopStore } from '../stores/storeDesktop'
+import { useDesktopDefaultAppsStore } from '../stores/storeDesktopDefaultApps'
 
 /**
- * Desktop Manager Composable (Singleton)
+ * Desktop Manager composable (singleton pattern via Pinia + app config).
+ * Agnostic of any theme: merges runtime shell config and exposes default-app routing.
  */
 export function useDesktopManager() {
+  const appConfig = useAppConfig()
+  const desktopStore = useDesktopStore()
+  const defaultAppsStore = useDesktopDefaultAppsStore()
+
   /**
-   * Merges and sets the desktop config at runtime
-   *
-   * @param newConfig
+   * Merges and sets the desktop config at runtime (shell geometry, feature flags, etc.).
    */
   function setConfig(newConfig: DesktopConfig) {
-    const appConfig = useAppConfig()
-
     appConfig.desktop = deepMerge(
       appConfig.desktop,
       newConfig,
     ) as DesktopConfig
   }
 
+  /** Map of feature name → default app handler (e.g. terminal, browser). */
+  const defaultApps = computed(
+    () => desktopStore.state.defaultApps,
+  )
+
+  function getDefaultApp(feature: string) {
+    return defaultAppsStore.getDefaultApp(feature)
+  }
+
+  function setDefaultApp(
+    feature: string,
+    application: IApplicationController,
+    entry: string,
+  ) {
+    defaultAppsStore.setDefaultApp(feature, application, entry)
+  }
+
   return {
     setConfig,
+    defaultApps,
+    getDefaultApp,
+    setDefaultApp,
   }
 }

package/runtime/composables/useOwdDialogs.ts

@@ -0,0 +1,13 @@
+import { inject } from 'vue'
+import {
+  OWD_DIALOG_PROVIDER_KEY,
+  createBrowserFallbackDialogProvider,
+  type OwdDialogProvider,
+} from '../dialogs/owdDialogProvider'
+
+/**
+ * Returns the active desktop dialog provider (theme) or a documented browser fallback.
+ */
+export function useOwdDialogs(): OwdDialogProvider {
+  return inject(OWD_DIALOG_PROVIDER_KEY, null) ?? createBrowserFallbackDialogProvider()
+}

package/runtime/composables/useWorkspaceOverview.ts

@@ -0,0 +1,41 @@
+import { useEventListener } from '@vueuse/core'
+import { useApplicationManager } from './useApplicationManager'
+import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace'
+
+/**
+ * Keyboard + HTML5 drop handlers for workspace overview (move windows between desktops).
+ */
+export function useWorkspaceOverview() {
+  const applicationManager = useApplicationManager()
+  const desktopWorkspaceStore = useDesktopWorkspaceStore()
+
+  useEventListener(window, 'keydown', (e: KeyboardEvent) => {
+    if (e.key !== 'Escape') return
+    if (!desktopWorkspaceStore.overview) return
+    desktopWorkspaceStore.setOverview(false)
+  })
+
+  function onWorkspaceDragOver(e: DragEvent) {
+    if (!desktopWorkspaceStore.overview) return
+    e.preventDefault()
+  }
+
+  function onWorkspaceDrop(e: DragEvent, workspaceId: string) {
+    e.preventDefault()
+    if (!desktopWorkspaceStore.overview) return
+
+    const raw =
+      e.dataTransfer?.getData('text/plain') ||
+      e.dataTransfer?.getData('text') ||
+      ''
+    if (!raw) return
+
+    const win = applicationManager.getWindowOpenedId(raw)
+    win?.actions.setWorkspace(workspaceId)
+  }
+
+  return {
+    onWorkspaceDragOver,
+    onWorkspaceDrop,
+  }
+}

package/runtime/core/controllers/ApplicationController.ts

@@ -7,7 +7,9 @@ import { useTerminalManager } from '../../composables/useTerminalManager'
 import { debugLog, debugError } from '../../utils/utilDebug'
 import { useDesktopDefaultAppsStore } from '../../stores/storeDesktopDefaultApps'
 import { useDesktopWorkspaceStore } from '../../stores/storeDesktopWorkspace'
-import { reactive } from '@vue/reactivity'
+import { useDesktopWindowStore } from '../../stores/storeDesktopWindow'
+import { shallowRef } from 'vue'
+import { unref } from 'vue'
 
 export class ApplicationController implements IApplicationController {
   private readonly applicationManager: IApplicationManager
@@ -16,9 +18,24 @@ export class ApplicationController implements IApplicationController {
   public readonly id
   public readonly config
   public readonly storeWindows
-  public readonly storeMeta
 
-  public windows = reactive(new Map<string, IWindowController>())
+  private readonly _windows = shallowRef(new Map<string, IWindowController>())
+
+  /** Reactive window count for Vue (class getters are not tracked). */
+  public readonly openWindowCount = shallowRef(0)
+
+  get windows(): Map<string, IWindowController> {
+    return this._windows.value
+  }
+
+  private replaceWindows(
+    mutator: (next: Map<string, IWindowController>) => void,
+  ) {
+    const next = new Map(this._windows.value)
+    mutator(next)
+    this._windows.value = next
+    this.openWindowCount.value = next.size
+  }
 
   public isRunning = false
 
@@ -29,7 +46,11 @@ export class ApplicationController implements IApplicationController {
     this.id = id
     this.config = config
     this.storeWindows = useApplicationWindowsStore(id)
-    this.storeMeta = useApplicationMetaStore(id)
+  }
+
+  /** Lazy meta store — app modules should register state via `useApplicationMetaStore` before `defineDesktopApp`. */
+  get storeMeta() {
+    return useApplicationMetaStore(this.id)()
   }
 
   public async initApplication(): Promise<void> {
@@ -127,9 +148,32 @@ export class ApplicationController implements IApplicationController {
       }
     })
 
+    this.normalizeWindowFocus()
+
     debugLog('Windows have been restored', this.windows)
   }
 
+  /** Ensure a single focused window after restore or stale persisted state. */
+  private normalizeWindowFocus() {
+    if (this.windows.size === 0) {
+      return
+    }
+
+    let topWindow: IWindowController | undefined
+    let topZ = -Infinity
+
+    for (const window of this.windows.values()) {
+      window.setFocus(false)
+      const z = window.state.position?.z ?? 0
+      if (z >= topZ) {
+        topZ = z
+        topWindow = window
+      }
+    }
+
+    topWindow?.setFocus(true)
+  }
+
   public openWindow(
     model: string,
     windowStoredState: WindowStoredState | undefined,
@@ -142,6 +186,20 @@ export class ApplicationController implements IApplicationController {
       return
     }
 
+    if (!windowStoredState && this.config.singleton) {
+      const existing = this.getFirstWindowByModel(model)
+      if (existing) {
+        if (meta && typeof meta === 'object') {
+          Object.assign(existing.meta, meta)
+        }
+        if (!meta?.isRestoring) {
+          existing.actions.setActive(true)
+          existing.actions.bringToFront()
+        }
+        return existing
+      }
+    }
+
     let windowId: string
 
     if (!windowStoredState) {
@@ -151,32 +209,54 @@ export class ApplicationController implements IApplicationController {
         model
       ] as WindowConfig
       const screenHeight = window.innerHeight
-      const centerY = (screenHeight - Number(windowConfig.size.height)) / 2
+      const configHeight = windowConfig.size?.height
+      const layoutHeight =
+        typeof configHeight === 'number'
+          ? configHeight
+          : typeof configHeight === 'string' && /^\d+$/.test(configHeight)
+            ? Number(configHeight)
+            : 240
+      const centerY = (screenHeight - layoutHeight) / 2
       const positionY =
         windowConfig.position?.y !== undefined
           ? window.scrollY + windowConfig.position.y
           : window.scrollY + centerY
-
-      this.storeWindows.windows[windowId] = {
-        model,
-        state: {
-          id: windowId,
-          active: true,
-          focused: false,
-          position: {
-            x: windowConfig.position?.x,
-            y: positionY,
+      const cascadeStep = 40
+      const cascadeOffset = this.getWindowsByModel(model).length * cascadeStep
+      const baseX = windowConfig.position?.x ?? 100
+      const desktopWindowStore = useDesktopWindowStore()
+      const initialZ = desktopWindowStore.incrementPositionZ()
+
+      const nextWindows = {
+        ...this.storeWindows.windows,
+        [windowId]: {
+          model,
+          state: {
+            id: windowId,
+            active: true,
+            focused: false,
+            position: {
+              x: baseX + cascadeOffset,
+              y: positionY + cascadeOffset,
+              z: initialZ,
+            },
+            createdAt: +new Date(),
+            workspace: desktopWorkspaceStore.resolveActiveWorkspaceId(),
           },
-          createdAt: +new Date(),
-          workspace: desktopWorkspaceStore.active,
+          meta,
         },
-        meta,
       }
+      this.storeWindows.windows = nextWindows
 
       windowStoredState = this.storeWindows.windows[windowId]
     } else {
       // restore previous id if state is defined
-      windowId = windowStoredState.state.id
+      windowId =
+        windowStoredState.state?.id ??
+        Object.keys(this.storeWindows.windows).find(
+          (key) => this.storeWindows.windows[key] === windowStoredState,
+        ) ??
+        `${model}-restored`
     }
 
     const windowConfig = this.config.windows[model] as WindowConfig
@@ -192,7 +272,9 @@ export class ApplicationController implements IApplicationController {
       windowController.actions.bringToFront()
     }
 
-    this.windows.set(windowId, windowController)
+    this.replaceWindows((next) => {
+      next.set(windowId, windowController)
+    })
 
     this.setRunning(true)
 
@@ -200,17 +282,25 @@ export class ApplicationController implements IApplicationController {
   }
 
   public closeWindow(windowId: string) {
-    delete this.storeWindows.windows[windowId]
-    this.windows.delete(windowId)
+    if (this.storeWindows.windows[windowId]) {
+      const nextWindows = { ...this.storeWindows.windows }
+      delete nextWindows[windowId]
+      this.storeWindows.windows = nextWindows
+    }
 
-    if (this.windows.size === 0) {
+    this.replaceWindows((next) => {
+      next.delete(windowId)
+    })
+
+    if (this.openWindowCount.value === 0) {
       this.applicationManager.closeApp(this.id)
     }
   }
 
   public closeAllWindows() {
     this.storeWindows.windows = {}
-    this.windows.clear()
+    this._windows.value = new Map()
+    this.openWindowCount.value = 0
   }
 
   get windowsOpened() {

package/runtime/core/controllers/WindowController.ts

@@ -202,18 +202,13 @@ export class WindowController implements IWindowController {
       this.state.position = { x: 0, y: 0, z: 0 }
     }
 
-    // already focused
-    if (this.state.focused) {
-      return
-    }
-
-    // set focus false on all other windows
-    for (const [windowId, window] of applicationManager.windowsOpened.value) {
-      window.actions.setFocus(false)
+    for (const window of applicationManager.windowsOpened.value.values()) {
+      if (window !== this) {
+        window.setFocus(false)
+      }
     }
 
     this.setFocus(true)
-
     this.state.position.z = desktopWindowStore.incrementPositionZ()
   }
 

package/runtime/dialogs/owdDialogProvider.ts

@@ -0,0 +1,81 @@
+import type { InjectionKey } from 'vue'
+
+/** Options for a yes/no confirmation (theme renders labels and chrome). */
+export interface OwdConfirmDialogOptions {
+  title?: string
+  message: string
+  danger?: boolean
+  acceptLabel?: string
+  rejectLabel?: string
+  /**
+   * Theme-specific payload (e.g. Win95 delete dialog passes `toTrash` for slot templates).
+   */
+  extras?: Record<string, unknown>
+}
+
+/**
+ * Cross-theme dialog API. Themes implement with PrimeVue, GNOME dialogs, etc.
+ * Callers pass user-facing strings (usually from i18n); implementations only render.
+ */
+export interface OwdDialogProvider {
+  confirm(options: OwdConfirmDialogOptions): Promise<boolean>
+  alert(message: string, options?: { title?: string }): Promise<void>
+  prompt(
+    message: string,
+    defaultValue?: string,
+  ): Promise<string | null>
+}
+
+export const OWD_DIALOG_PROVIDER_KEY: InjectionKey<OwdDialogProvider> =
+  Symbol('owd-dialog-provider')
+
+function browserGlobals(): {
+  confirm: (message?: string) => boolean
+  alert: (message?: string) => void
+  prompt: (message?: string, defaultText?: string) => string | null
+} | null {
+  const g = globalThis as typeof globalThis & {
+    confirm?: (message?: string) => boolean
+    alert?: (message?: string) => void
+    prompt?: (message?: string, defaultText?: string) => string | null
+  }
+  if (typeof g.confirm !== 'function') return null
+  return {
+    confirm: g.confirm.bind(g),
+    alert:
+      typeof g.alert === 'function'
+        ? g.alert.bind(g)
+        : (m?: string) => {
+            void m
+          },
+    prompt:
+      typeof g.prompt === 'function'
+        ? g.prompt.bind(g)
+        : () => null,
+  }
+}
+
+export function createBrowserFallbackDialogProvider(): OwdDialogProvider {
+  return {
+    async confirm(opts) {
+      if (import.meta.server) return false
+      const w = browserGlobals()
+      if (!w) return false
+      const text = [opts.title, opts.message].filter(Boolean).join('\n\n')
+      return w.confirm(text)
+    },
+    async alert(message, opts) {
+      if (import.meta.server) return
+      const w = browserGlobals()
+      if (!w) return
+      w.alert([opts?.title, message].filter(Boolean).join('\n\n'))
+    },
+    async prompt(message, defaultValue = '') {
+      if (import.meta.server) return null
+      const w = browserGlobals()
+      if (!w) return null
+      const v = w.prompt(message, defaultValue)
+      return v === null ? null : v
+    },
+  }
+}

package/runtime/plugins/01.owd-dialogs-fallback.ts

@@ -0,0 +1,15 @@
+import { defineNuxtPlugin } from 'nuxt/app'
+import {
+  OWD_DIALOG_PROVIDER_KEY,
+  createBrowserFallbackDialogProvider,
+} from '../dialogs/owdDialogProvider'
+
+export default defineNuxtPlugin({
+  name: 'owd-dialogs-fallback',
+  setup(nuxtApp) {
+    nuxtApp.vueApp.provide(
+      OWD_DIALOG_PROVIDER_KEY,
+      createBrowserFallbackDialogProvider(),
+    )
+  },
+})

package/runtime/stores/storeApplicationMeta.ts

@@ -1,15 +1,59 @@
 import { defineStore } from 'pinia'
+import { ref } from 'vue'
 
-export const useApplicationMetaStore = (appId: string, states: any = {}) => {
-  return defineStore(
-    `owd/application/${appId}/meta`,
-    () => {
-      return states
-    },
-    {
-      persistedState: {
-        persist: true,
-      },
-    },
-  )
+const metaStoreRegistry = new Map<string, ReturnType<typeof defineStore>>()
+/** Store ids created by the generic fallback (only `meta`), replaceable when an app registers real state. */
+const fallbackMetaStoreIds = new Set<string>()
+
+type MetaStoreSetup = (() => Record<string, unknown>) | Record<string, unknown>
+
+function resolveSetup(states: MetaStoreSetup) {
+  return typeof states === 'function' ? states : () => states
+}
+
+/**
+ * Per-app Pinia meta store factory. The first registration for an app id wins so
+ * app modules should call this from their store module (imported in the app plugin
+ * before `defineDesktopApp`).
+ */
+export const useApplicationMetaStore = (
+  appId: string,
+  states?: MetaStoreSetup,
+) => {
+  const id = `owd/application/${appId}/meta`
+
+  if (
+    states !== undefined &&
+    (!metaStoreRegistry.has(id) || fallbackMetaStoreIds.has(id))
+  ) {
+    fallbackMetaStoreIds.delete(id)
+    metaStoreRegistry.set(
+      id,
+      defineStore(id, resolveSetup(states), {
+        persistedState: {
+          persist: true,
+        },
+      }),
+    )
+  }
+
+  if (!metaStoreRegistry.has(id)) {
+    fallbackMetaStoreIds.add(id)
+    metaStoreRegistry.set(
+      id,
+      defineStore(
+        id,
+        () => ({
+          meta: ref<Record<string, unknown>>({}),
+        }),
+        {
+          persistedState: {
+            persist: true,
+          },
+        },
+      ),
+    )
+  }
+
+  return metaStoreRegistry.get(id)!
 }