@owdproject/core 3.1.3 → 3.1.4

package/runtime/composables/useDesktopManager.ts

@@ -1,7 +1,25 @@
-import {DesktopManager} from "../core/managers/DesktopManager";
-
-const desktopManager = new DesktopManager()
+import { deepMerge } from '../utils/utilCommon'
+import { useAppConfig } from 'nuxt/app'
 
+/**
+ * Desktop Manager Composable (Singleton)
+ */
 export function useDesktopManager() {
-    return desktopManager
+  /**
+   * Merges and sets the desktop config at runtime
+   *
+   * @param newConfig
+   */
+  function setConfig(newConfig: DesktopConfig) {
+    const appConfig = useAppConfig()
+
+    appConfig.desktop = deepMerge(
+      appConfig.desktop,
+      newConfig,
+    ) as DesktopConfig
+  }
+
+  return {
+    setConfig,
+  }
 }

package/runtime/composables/useTerminalManager.ts

@@ -1,7 +1,66 @@
-import {TerminalManager} from "../core/managers/TerminalManager";
+import { useApplicationManager } from './useApplicationManager'
+import { debugLog } from '../utils/utilDebug'
 
-const terminalManager = new TerminalManager()
+const commands = new Map<string, TerminalCommand>()
 
+/**
+ * Terminal Manager Composable (Singleton)
+ */
 export function useTerminalManager() {
-    return terminalManager
-}
+  /**
+   * 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/core/controllers/ApplicationController.ts

@@ -1,244 +1,255 @@
-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 {useDesktopManager} from "../../composables/useDesktopManager"
-import {debugLog, debugError} from "../../utils/utilDebug"
-import {useDesktopWorkspaceStore} from "../../stores/storeDesktopWorkspace"
-import {reactive} from '@vue/reactivity'
+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 { reactive } from '@vue/reactivity'
 
 export class ApplicationController implements IApplicationController {
-    private readonly applicationManager: IApplicationManager
-    private readonly desktopManager: IDesktopManager
-    private readonly terminalManager: ITerminalManager
+  private readonly applicationManager: IApplicationManager
+  private readonly terminalManager: ITerminalManager
 
-    public readonly id
-    public readonly config
-    public readonly store
+  public readonly id
+  public readonly config
+  public readonly storeWindows
+  public readonly storeMeta
 
-    public windows = reactive(new Map<string, IWindowController>())
+  public windows = reactive(new Map<string, IWindowController>())
 
-    public isRunning: boolean = false
+  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)
-    }
-
-    public async initApplication(): Promise<void> {
-
-        // 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(this.config.provides.name)
+  constructor(id: string, config: ApplicationConfig) {
+    this.applicationManager = useApplicationManager()
+    this.terminalManager = useTerminalManager()
 
-            if (!existingDefault) {
-                this.desktopManager.setDefaultApp(
-                    this.config.provides.name,
-                    this,
-                    this.config.entries[this.config.provides.entry] as ApplicationEntry
-                )
+    this.id = id
+    this.config = config
+    this.storeWindows = useApplicationWindowsStore(id)
+    this.storeMeta = useApplicationMetaStore(id)
+  }
 
-                debugLog(`${this.config.title} has been set as predefined app for "${this.config.provides.name}"`)
-            }
-        }
+  public async initApplication(): Promise<void> {
+    const desktopDefaultAppsStore = useDesktopDefaultAppsStore()
 
-        // terminal
+    // provides
 
-        if (this.config.commands) {
-            for (const commandKey of Object.keys(this.config.commands)) {
-                this.terminalManager.addCommand({
-                    applicationId: this.id,
-                    name: commandKey
-                })
-            }
-        }
+    // 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,
+      )
 
-        // 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()
+      if (!existingDefault) {
+        desktopDefaultAppsStore.setDefaultApp(
+          this.config.provides.name,
+          this,
+          this.config.provides.entry,
+        )
 
-        // once app is defined, always run "onReady"
-        if (typeof this.config.onReady === 'function') {
-            // todo transform in hook
-            this.config.onReady(this)
-        }
+        debugLog(
+          `${this.config.title} has been set as predefined app for "${this.config.provides.name}"`,
+        )
+      }
     }
 
-    /**
-     * 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)
-        }
+    // terminal
 
-        if (!this.storeWindows.windows || Object.keys(this.storeWindows.windows).length === 0) {
-            return false
-        }
+    if (this.config.commands) {
+      for (const commandKey of Object.keys(this.config.commands)) {
+        this.terminalManager.addCommand({
+          applicationId: this.id,
+          name: commandKey,
+        })
+      }
+    }
 
-        this.restoreWindows()
+    // store
 
-        this.setRunning(true)
+    if (this.storeWindows.$persistedState) {
+      await this.storeWindows.$persistedState.isReady()
+    }
 
-        return true
+    if (this.storeMeta.$persistedState) {
+      await this.storeMeta.$persistedState.isReady()
     }
 
-    private restoreWindows() {
-        Object.keys(this.storeWindows.windows).map(windowId => {
-            const windowStore: WindowStoredState | undefined = this.storeWindows.windows[windowId]
+    // set default meta values
+    // this.storeMeta.meta = this.config.meta ?? {}
 
-            if (windowStore) {
-                this.openWindow(windowStore.model, windowStore, {isRestoring: true})
-            }
-        })
+    // restore application state
+    await this.restoreApplication()
 
-        debugLog('Windows have been restored', this.windows)
+    // 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)
     }
 
-    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
-        }
-
-        let windowId: string
+    if (
+      !this.storeWindows.windows ||
+      Object.keys(this.storeWindows.windows).length === 0
+    ) {
+      return false
+    }
 
-        if (!windowStoredState) {
+    this.restoreWindows()
 
-            windowId = `${model}-${nanoid(6)}`
+    this.setRunning(true)
 
-            const windowConfig: WindowConfig = this.config.windows[model] as WindowConfig
-            const screenHeight = window.innerHeight
-            const centerY = (screenHeight - Number(windowConfig.size.height)) / 2
-            const positionY = windowConfig.position?.y !== undefined
-                ? window.scrollY + windowConfig.position.y
-                : window.scrollY + centerY
+    return true
+  }
 
-            this.storeWindows.windows[windowId] = {
-                model,
-                state: {
-                    id: windowId,
-                    active: true,
-                    focused: false,
-                    position: {
-                        x: windowConfig.position?.x,
-                        y: positionY,
-                    },
-                    createdAt: +new Date(),
-                    workspace: desktopWorkspaceStore.active
-                },
-                meta
-            }
+  private restoreWindows() {
+    Object.keys(this.storeWindows.windows).map((windowId) => {
+      const windowStore: WindowStoredState | undefined =
+        this.storeWindows.windows[windowId]
 
-            windowStoredState = this.storeWindows.windows[windowId]
+      if (windowStore) {
+        this.openWindow(windowStore.model, windowStore, {
+          isRestoring: true,
+        })
+      }
+    })
+
+    debugLog('Windows have been restored', this.windows)
+  }
+
+  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
+    }
 
-        } else {
+    let windowId: string
+
+    if (!windowStoredState) {
+      windowId = `${model}-${nanoid(6)}`
+
+      const windowConfig: WindowConfig = this.config.windows[
+        model
+      ] as WindowConfig
+      const screenHeight = window.innerHeight
+      const centerY = (screenHeight - Number(windowConfig.size.height)) / 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,
+          },
+          createdAt: +new Date(),
+          workspace: desktopWorkspaceStore.active,
+        },
+        meta,
+      }
+
+      windowStoredState = this.storeWindows.windows[windowId]
+    } else {
+      // restore previous id if state is defined
+      windowId = windowStoredState.state.id
+    }
 
-            // restore previous id if state is defined
-            windowId = windowStoredState.state.id
+    const windowConfig = this.config.windows[model] as WindowConfig
 
-        }
+    const windowController = new WindowController(
+      this,
+      model,
+      windowConfig,
+      windowStoredState!,
+    )
 
-        const windowConfig = this.config.windows[model] as WindowConfig
+    if (!meta?.isRestoring) {
+      windowController.actions.bringToFront()
+    }
 
-        const windowController = new WindowController(
-            this,
-            model,
-            windowConfig,
-            windowStoredState!
-        )
+    this.windows.set(windowId, windowController)
 
-        if (!meta?.isRestoring) {
-            windowController.actions.bringToFront()
-        }
+    this.setRunning(true)
 
-        this.windows.set(
-            windowId,
-            windowController,
-        )
+    return windowController
+  }
 
-        this.setRunning(true)
+  public closeWindow(windowId: string) {
+    delete this.storeWindows.windows[windowId]
+    this.windows.delete(windowId)
 
-        return windowController
+    if (this.windows.size === 0) {
+      this.applicationManager.closeApp(this.id)
     }
+  }
 
-    public closeWindow(windowId: string) {
-        delete this.storeWindows.windows[windowId];
-        this.windows.delete(windowId);
-
-        if (this.windows.size === 0) {
-            this.applicationManager.closeApp(this.id)
-        }
-    }
+  public closeAllWindows() {
+    this.storeWindows.windows = {}
+    this.windows.clear()
+  }
 
-    public closeAllWindows() {
-        this.storeWindows.windows = {}
-        this.windows.clear()
-    }
+  get windowsOpened() {
+    return this.windows
+  }
 
-    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 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 getFirstWindowByModel(model: string): IWindowController | undefined {
+    return Array.from(this.windows.values()).find((w) => w.model === model)
+  }
 
-    public setRunning(value: boolean): void {
-        this.isRunning = value
-    }
+  public setRunning(value: boolean): void {
+    this.isRunning = value
+  }
 
-    // meta
+  // meta
 
-    get meta() {
-        return this.storeMeta.meta
-    }
+  get meta() {
+    return this.storeMeta.meta
+  }
 
-    getMeta(key: string) {
-        return this.meta[key]
-    }
+  getMeta(key: string) {
+    return this.meta[key]
+  }
 
-    setMeta(key: string, value: any) {
-        this.meta[key] = value
-    }
+  setMeta(key: string, value: any) {
+    this.meta[key] = value
+  }
 
-    // commands
+  // commands
 
-    async execCommand(command: string): Promise<CommandOutput | void> {
-        return this.applicationManager.execAppCommand(this.id, command)
-    }
+  async execCommand(command: string): Promise<CommandOutput | void> {
+    return this.applicationManager.execAppCommand(this.id, command)
+  }
 }