@owdproject/core 3.1.4-beta.0 → 3.2.0

package/runtime/core/controllers/ApplicationController.ts

@@ -4,51 +4,72 @@ import { useApplicationManager } from '../../composables/useApplicationManager'
 import { useApplicationWindowsStore } from '../../stores/storeApplicationWindows'
 import { useApplicationMetaStore } from '../../stores/storeApplicationMeta'
 import { useTerminalManager } from '../../composables/useTerminalManager'
-import { useDesktopManager } from '../../composables/useDesktopManager'
 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
-  private readonly desktopManager: IDesktopManager
   private readonly terminalManager: ITerminalManager
 
   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
 
   constructor(id: string, config: ApplicationConfig) {
     this.applicationManager = useApplicationManager()
     this.terminalManager = useTerminalManager()
-    this.desktopManager = useDesktopManager()
 
     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> {
+    const desktopDefaultAppsStore = useDesktopDefaultAppsStore()
+
     // provides
 
     // set as default app for specific purposes
     // todo improve this and move it in a store
     if (this.config.provides) {
-      const existingDefault = this.desktopManager.getDefaultApp(
+      const existingDefault = desktopDefaultAppsStore.getDefaultApp(
         this.config.provides.name,
       )
 
       if (!existingDefault) {
-        this.desktopManager.setDefaultApp(
+        desktopDefaultAppsStore.setDefaultApp(
           this.config.provides.name,
           this,
-          this.config.provides.command,
+          this.config.provides.entry,
         )
 
         debugLog(
@@ -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) {
-      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()
   }
 
@@ -283,7 +278,7 @@ export class WindowController implements IWindowController {
       maxHeight:
         typeof stateSize.maxHeight !== 'undefined'
           ? stateSize.maxHeight
-          : (configSize.maxHeight ?? 600),
+          : configSize.maxHeight,
     }
   }
 

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)!
 }

package/runtime/stores/storeDesktop.ts

@@ -1,6 +1,41 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
 
+export type DesktopWindowSurface = 'acrylic' | 'solid'
+
+export type DesktopAppearance = 'dark' | 'light'
+
+export type DesktopPersonalization = {
+  windowSurface: DesktopWindowSurface
+  /** Used when windowSurface is solid (CSS color string). */
+  windowTint: string
+  appearance: DesktopAppearance
+}
+
+export const defaultDesktopPersonalization: DesktopPersonalization = {
+  windowSurface: 'acrylic',
+  windowTint: '#2d2d30',
+  appearance: 'dark',
+}
+
+export function mergePersonalization(
+  raw: Partial<DesktopPersonalization> | undefined | null,
+): DesktopPersonalization {
+  const windowSurface =
+    raw?.windowSurface === 'solid' || raw?.windowSurface === 'acrylic'
+      ? raw.windowSurface
+      : defaultDesktopPersonalization.windowSurface
+  const appearance =
+    raw?.appearance === 'light' || raw?.appearance === 'dark'
+      ? raw.appearance
+      : defaultDesktopPersonalization.appearance
+  const tint =
+    typeof raw?.windowTint === 'string' && raw.windowTint.trim()
+      ? raw.windowTint.trim()
+      : defaultDesktopPersonalization.windowTint
+  return { windowSurface, windowTint: tint, appearance }
+}
+
 export const useDesktopStore = defineStore(
   'owd/desktop',
   () => {
@@ -16,6 +51,12 @@ export const useDesktopStore = defineStore(
       window: {
         positionZ: number
       }
+      explorer: {
+        navExpandedKeys: string[]
+        quickAccessPins: { id: string; label: string; path: string; icon?: string }[]
+      }
+      defaultApps: Record<string, { applicationId: string; entry: string }>
+      personalization: DesktopPersonalization
     }>({
       workspace: {
         overview: false,
@@ -28,10 +69,48 @@ export const useDesktopStore = defineStore(
       window: {
         positionZ: 0,
       },
+      explorer: {
+        navExpandedKeys: [
+          'quickAccess',
+          'thisPc',
+        ],
+        quickAccessPins: [],
+      },
+      defaultApps: {},
+      personalization: { ...defaultDesktopPersonalization },
     })
 
+    function setWindowSurface(value: DesktopWindowSurface) {
+      const base = mergePersonalization(state.value.personalization)
+      state.value.personalization = mergePersonalization({
+        ...base,
+        windowSurface: value,
+      })
+    }
+
+    function setWindowTint(value: string) {
+      const v = value.trim()
+      if (!v) return
+      const base = mergePersonalization(state.value.personalization)
+      state.value.personalization = mergePersonalization({
+        ...base,
+        windowTint: v,
+      })
+    }
+
+    function setAppearance(value: DesktopAppearance) {
+      const base = mergePersonalization(state.value.personalization)
+      state.value.personalization = mergePersonalization({
+        ...base,
+        appearance: value,
+      })
+    }
+
     return {
       state,
+      setWindowSurface,
+      setWindowTint,
+      setAppearance,
     }
   },
   {

package/runtime/stores/storeDesktopDefaultApps.ts

@@ -0,0 +1,53 @@
+import { defineStore } from 'pinia'
+import { useDesktopStore } from './storeDesktop'
+
+export const useDesktopDefaultAppsStore = defineStore(
+  'owd/desktop/defaultApps',
+  () => {
+    const desktopStore = useDesktopStore()
+
+    /**
+     * Sets a default app for a given feature
+     */
+    function setDefaultApp(
+      feature: string,
+      application: IApplicationController,
+      entry: string,
+    ) {
+      if (!desktopStore.state.hasOwnProperty('defaultApps')) {
+        desktopStore.state.defaultApps = {}
+      }
+
+      desktopStore.state.defaultApps[feature] = {
+        applicationId: application.id,
+        entry,
+      }
+    }
+
+    /**
+     * Gets the default app config for a given feature
+     */
+    function getDefaultApp(feature: string): DefaultAppConfig | undefined {
+      if (!desktopStore.state.hasOwnProperty('defaultApps')) {
+        desktopStore.state.defaultApps = {}
+      }
+
+      return desktopStore.state.defaultApps[feature]
+    }
+
+    /**
+     * Loads default apps from current config
+     */
+    function loadDefaultAppsFromConfig(runtimeConfig) {
+      if (runtimeConfig.public.desktop.defaultApps) {
+        desktopStore.state.defaultApps = runtimeConfig.public.desktop.defaultApps
+      }
+    }
+
+    return {
+      setDefaultApp,
+      getDefaultApp,
+      loadDefaultAppsFromConfig,
+    }
+  },
+)

package/runtime/stores/storeDesktopExplorer.ts

@@ -0,0 +1,74 @@
+import { defineStore } from 'pinia'
+import { computed } from 'vue'
+import { useDesktopStore } from './storeDesktop'
+
+type ExplorerQuickAccessPin = {
+  id: string
+  label: string
+  path: string
+  icon?: string
+}
+
+export const useDesktopExplorerStore = defineStore(
+  'owd/desktop/explorer',
+  () => {
+    const desktopStore = useDesktopStore()
+
+    const navExpandedKeys = computed(
+      () => desktopStore.state.explorer.navExpandedKeys,
+    )
+    const quickAccessPins = computed(
+      () => desktopStore.state.explorer.quickAccessPins,
+    )
+
+    function setNavExpandedKeys(keys: string[]) {
+      desktopStore.state.explorer.navExpandedKeys = [...new Set(keys)]
+    }
+
+    function setQuickAccessPins(pins: ExplorerQuickAccessPin[]) {
+      desktopStore.state.explorer.quickAccessPins = pins
+    }
+
+    function pinQuickAccess(entry: ExplorerQuickAccessPin) {
+      const exists = desktopStore.state.explorer.quickAccessPins.some(
+        (pin) => pin.path === entry.path,
+      )
+      if (exists) return
+      desktopStore.state.explorer.quickAccessPins.push(entry)
+    }
+
+    function unpinQuickAccess(path: string) {
+      desktopStore.state.explorer.quickAccessPins =
+        desktopStore.state.explorer.quickAccessPins.filter(
+          (pin) => pin.path !== path,
+        )
+    }
+
+    function reorderQuickAccess(startIndex: number, endIndex: number) {
+      const list = [...desktopStore.state.explorer.quickAccessPins]
+      if (
+        startIndex < 0 ||
+        endIndex < 0 ||
+        startIndex >= list.length ||
+        endIndex >= list.length ||
+        startIndex === endIndex
+      ) {
+        return
+      }
+      const [item] = list.splice(startIndex, 1)
+      if (!item) return
+      list.splice(endIndex, 0, item)
+      desktopStore.state.explorer.quickAccessPins = list
+    }
+
+    return {
+      navExpandedKeys,
+      quickAccessPins,
+      setNavExpandedKeys,
+      setQuickAccessPins,
+      pinQuickAccess,
+      unpinQuickAccess,
+      reorderQuickAccess,
+    }
+  },
+)