@owdproject/core 3.3.1 → 4.0.0-alpha.3

package/runtime/composables/useDesktopManager.ts

@@ -1,49 +0,0 @@
-import { computed } from 'vue'
-import { useAppConfig } from 'nuxt/app'
-import { defu } from 'defu'
-import { useDesktopStore } from '../stores/storeDesktop'
-import { useDesktopDefaultAppsStore } from '../stores/storeDesktopDefaultApps'
-
-/**
- * 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 (shell geometry, feature flags, etc.).
-   */
-  function setConfig(newConfig: DesktopConfig) {
-    appConfig.desktop = defu(
-      newConfig,
-      (appConfig.desktop ?? {}) as DesktopConfig,
-    ) 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/useTerminalManager.ts

@@ -1,66 +0,0 @@
-import { useApplicationManager } from './useApplicationManager'
-import { debugLog } from '../utils/utilDebug'
-
-const commands = new Map<string, TerminalCommand>()
-
-/**
- * Terminal Manager Composable (Singleton)
- */
-export function useTerminalManager() {
-  /**
-   * Add a new terminal command
-   *
-   * @param command
-   */
-  const addCommand = (command: TerminalCommand) => {
-    for (const existingCommand of commands.keys()) {
-      if (
-        existingCommand.startsWith(command.name) ||
-        command.name.startsWith(existingCommand)
-      ) {
-        throw new Error(`Command prefix conflict with "${existingCommand}"`)
-      }
-    }
-
-    commands.set(command.name, command)
-    debugLog(`Registered terminal command: ${command.name} → ${command.applicationId}`)
-  }
-
-  /**
-   * List all registered command names
-   */
-  const listCommands = (): string[] => {
-    return Array.from(commands.keys())
-  }
-
-  /**
-   * Execute a terminal command
-   *
-   * @param input
-   */
-  const execCommand = async (input: string): Promise<CommandOutput | void> => {
-    const applicationManager = useApplicationManager()
-
-    const [name, ...args] = input.trim().split(/\s+/)
-
-    if (!name) {
-      return
-    }
-
-    if (!commands.has(name)) {
-      return {
-        message: `Command "${name}" not found`,
-      }
-    }
-
-    const application = commands.get(name)!
-
-    return applicationManager.execAppCommand(application.applicationId, input)
-  }
-
-  return {
-    addCommand,
-    listCommands,
-    execCommand,
-  }
-}

package/runtime/composables/useWorkspaceManager.ts

@@ -1,41 +0,0 @@
-import { useEventListener } from '@vueuse/core'
-import { useApplicationManager } from './useApplicationManager'
-import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace'
-
-/**
- * Keyboard + HTML5 drop handlers for workspace management (move windows between desktops).
- */
-export function useWorkspaceManager() {
-  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/internal/controllers/ApplicationController.ts

@@ -1,345 +0,0 @@
-import { nanoid } from 'nanoid'
-import { WindowController } from './WindowController'
-import { useApplicationManager } from '../../composables/useApplicationManager'
-import { useApplicationWindowsStore } from '../../stores/storeApplicationWindows'
-import { useApplicationMetaStore } from '../../stores/storeApplicationMeta'
-import { useTerminalManager } from '../../composables/useTerminalManager'
-import { debugLog, debugError } from '../../utils/utilDebug'
-import { useDesktopDefaultAppsStore } from '../../stores/storeDesktopDefaultApps'
-import { useDesktopWorkspaceStore } from '../../stores/storeDesktopWorkspace'
-import { useDesktopWindowStore } from '../../stores/storeDesktopWindow'
-import { shallowRef } from 'vue'
-import { unref } from 'vue'
-
-export class ApplicationController implements IApplicationController {
-  private readonly applicationManager: IApplicationManager
-  private readonly terminalManager: ITerminalManager
-
-  public readonly id
-  public readonly config
-  public readonly storeWindows
-
-  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.id = id
-    this.config = config
-    this.storeWindows = useApplicationWindowsStore(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 = desktopDefaultAppsStore.getDefaultApp(
-        this.config.provides.name,
-      )
-
-      if (!existingDefault) {
-        desktopDefaultAppsStore.setDefaultApp(
-          this.config.provides.name,
-          this,
-          this.config.provides.entry,
-        )
-
-        debugLog(
-          `${this.config.title} has been set as predefined app for "${this.config.provides.name}"`,
-        )
-      }
-    }
-
-    // terminal
-
-    if (this.config.commands) {
-      for (const commandKey of Object.keys(this.config.commands)) {
-        this.terminalManager.addCommand({
-          applicationId: this.id,
-          name: commandKey,
-        })
-      }
-    }
-
-    // store
-
-    if (this.storeWindows.$persistedState) {
-      await this.storeWindows.$persistedState.isReady()
-    }
-
-    if (this.storeMeta.$persistedState) {
-      await this.storeMeta.$persistedState.isReady()
-    }
-
-    // set default meta values
-    // this.storeMeta.meta = this.config.meta ?? {}
-
-    // restore application state
-    await this.restoreApplication()
-
-    // once app is defined, always run "onReady"
-    if (typeof this.config.onReady === 'function') {
-      // todo transform in hook
-      this.config.onReady(this)
-    }
-  }
-
-  /**
-   * App always tries to restore previous windows
-   * and returns a boolean if it succeeded
-   */
-  public async restoreApplication() {
-    if (typeof this.config.onRestore === 'function') {
-      // todo transform in hook
-      await this.config.onRestore(this)
-    }
-
-    if (
-      !this.storeWindows.windows ||
-      Object.keys(this.storeWindows.windows).length === 0
-    ) {
-      return false
-    }
-
-    this.restoreWindows()
-
-    this.setRunning(true)
-
-    return true
-  }
-
-  private restoreWindows() {
-    Object.keys(this.storeWindows.windows).map((windowId) => {
-      const windowStore: WindowStoredState | undefined =
-        this.storeWindows.windows[windowId]
-
-      if (windowStore) {
-        this.openWindow(windowStore.model, windowStore, {
-          isRestoring: true,
-        })
-      }
-    })
-
-    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,
-    meta?: any,
-  ) {
-    const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-    if (!this.config.windows || !this.config.windows.hasOwnProperty(model)) {
-      debugError(`Window model "${model}" not found`)
-      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) {
-      windowId = `${model}-${nanoid(6)}`
-
-      const windowConfig: WindowConfig = this.config.windows[
-        model
-      ] as WindowConfig
-      const screenHeight = window.innerHeight
-      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
-      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(),
-          },
-          meta,
-        },
-      }
-      this.storeWindows.windows = nextWindows
-
-      windowStoredState = this.storeWindows.windows[windowId]
-    } else {
-      // restore previous id if state is defined
-      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
-
-    const windowController = new WindowController(
-      this,
-      model,
-      windowConfig,
-      windowStoredState!,
-    )
-
-    if (!meta?.isRestoring) {
-      windowController.actions.bringToFront()
-    }
-
-    this.replaceWindows((next) => {
-      next.set(windowId, windowController)
-    })
-
-    this.setRunning(true)
-
-    return windowController
-  }
-
-  public closeWindow(windowId: string) {
-    if (this.storeWindows.windows[windowId]) {
-      const nextWindows = { ...this.storeWindows.windows }
-      delete nextWindows[windowId]
-      this.storeWindows.windows = nextWindows
-    }
-
-    this.replaceWindows((next) => {
-      next.delete(windowId)
-    })
-
-    if (this.openWindowCount.value === 0) {
-      this.applicationManager.closeApp(this.id)
-    }
-  }
-
-  public closeAllWindows() {
-    this.storeWindows.windows = {}
-    this._windows.value = new Map()
-    this.openWindowCount.value = 0
-  }
-
-  get windowsOpened() {
-    return this.windows
-  }
-
-  public getWindowById(id: string): IWindowController[] {
-    return this.windows.get(id)
-  }
-
-  public getWindowsByModel(model: string): IWindowController[] {
-    return Array.from(this.windows.values()).filter((w) => w.model === model)
-  }
-
-  public getFirstWindowByModel(model: string): IWindowController | undefined {
-    return Array.from(this.windows.values()).find((w) => w.model === model)
-  }
-
-  public setRunning(value: boolean): void {
-    this.isRunning = value
-  }
-
-  // meta
-
-  get meta() {
-    return this.storeMeta.meta
-  }
-
-  getMeta(key: string) {
-    return this.meta[key]
-  }
-
-  setMeta(key: string, value: any) {
-    this.meta[key] = value
-  }
-
-  // commands
-
-  async execCommand(command: string): Promise<CommandOutput | void> {
-    return this.applicationManager.execAppCommand(this.id, command)
-  }
-}