@owdproject/core 3.1.3 → 3.1.4-beta.0

package/runtime/core/managers/ApplicationManager.ts

@@ -1,237 +1,281 @@
-import type {Reactive} from "@vue/reactivity"
-import {reactive, markRaw} from "@vue/reactivity"
-import {ApplicationController} from "../controllers/ApplicationController";
-import {normalizeApplicationConfig} from "../../utils/utilApp"
-import {debugLog} from "../../utils/utilDebug"
+import type { Reactive } from '@vue/reactivity'
+import { reactive, markRaw } from '@vue/reactivity'
+import { ApplicationController } from '../controllers/ApplicationController'
+import { normalizeApplicationConfig } from '../../utils/utilApp'
+import { debugLog } from '../../utils/utilDebug'
+import * as shellwords from 'shellwords'
+import yargsParser from 'yargs-parser'
 
 export class ApplicationManager implements IApplicationManager {
-    public apps = reactive(
-        new Map<string, IApplicationController>()
-    )
-
-    constructor() {
+  public apps = reactive(new Map<string, IApplicationController>())
+
+  constructor() {}
+
+  /**
+   * Define new application
+   *
+   * @param id
+   * @param config
+   */
+  public async defineApp(id: string, config: ApplicationConfig) {
+    if (this.isAppDefined(id)) {
+      debugLog(`App "${id}" is already defined`)
+      return this.getAppById(id)!
     }
 
-    /**
-     * Define new application
-     *
-     * @param id
-     * @param config
-     */
-    public async defineApp(id: string, config: ApplicationConfig) {
-        if (this.isAppDefined(id)) {
-            debugLog(`App "${id}" is already defined`);
-            return this.apps.get(id)!;
-        }
-
-        const normalizedConfig = normalizeApplicationConfig(config)
-        const applicationConfig = markRaw(normalizedConfig)
-
-        const applicationController: IApplicationController = new ApplicationController(id, applicationConfig)
-        await applicationController.initApplication()
+    const normalizedConfig = normalizeApplicationConfig(config)
+    const applicationConfig = markRaw(normalizedConfig)
+
+    const applicationController: IApplicationController = new ApplicationController(id, applicationConfig)
+    await applicationController.initApplication()
+
+    this.apps.set(id, applicationController)
+
+    return applicationController
+  }
+
+  /**
+   * Check if app has been defned
+   *
+   * @param {string} id
+   */
+  public isAppDefined(id: string) {
+    return this.getAppById(id)
+  }
+
+  /**
+   * Retrieves an app instance by its unique identifier
+   *
+   * @param {string} id
+   */
+  public getAppById(id: string) {
+    return this.apps.get(id)
+  }
+
+  /**
+   * Check if app is running
+   *
+   * @param {string} id
+   */
+  public isAppRunning(id: string) {
+    if (!this.isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
+    }
 
-        this.apps.set(id, applicationController)
+    const applicationController: IApplicationController = this.getAppById(id)!
 
-        return applicationController
+    if (!applicationController.isRunning) {
+      return false
     }
 
-    /**
-     * Check if app has been defned
-     *
-     * @param id
-     */
-    public isAppDefined(id: string) {
-        return this.apps.has(id)
+    return true
+  }
+
+  /**
+   * Launch app entry
+   *
+   * @param id
+   * @param entryKey
+   */
+  public async launchAppEntry(
+    id: string,
+    entryKey: string,
+  ): Promise<IApplicationController | undefined | void> {
+    if (!this.isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
     }
 
-    /**
-     * Check if app is running
-     *
-     * @param id
-     */
-    public isAppRunning(id: string) {
-        if (!this.isAppDefined(id)) {
-            throw Error(`App "${id}" is not defined`);
-        }
+    const applicationController: IApplicationController = this.getAppById(id)!
 
-        const applicationController: IApplicationController = this.apps.get(id)!
-
-        if (!applicationController.isRunning) {
-            return false
-        }
-
-        return true
+    if (
+      applicationController.config.entries &&
+      !applicationController.config.entries.hasOwnProperty(entryKey)
+    ) {
+      throw Error(`App entry "${entryKey}" is not defined in ${id} application`)
     }
 
-    /**
-     * Launch app rntry
-     *
-     * @param id
-     * @param entryKey
-     */
-    public async launchAppEntry(id: string, entryKey: string): Promise<IApplicationController | undefined | void> {
-        if (!this.isAppDefined(id)) {
-            throw Error(`App "${id}" is not defined`);
-        }
-
-        const applicationController: IApplicationController = this.apps.get(id)!
+    const entry: ApplicationEntry = applicationController.config.entries[entryKey]!
+
+    await this.execAppCommand(applicationController.id, entry.command)
+  }
+
+  /**
+   * Run app command
+   *
+   * @param id
+   * @param rawCommand
+   */
+  public async execAppCommand(
+    id: string,
+    rawCommand: string,
+  ): Promise<CommandOutput> {
+    if (!this.isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
+    }
 
-        if (applicationController.config.entries && !applicationController.config.entries.hasOwnProperty(entryKey)) {
-            throw Error(`App entry "${entryKey}" is not defined in ${id} application`);
-        }
+    const applicationController: IApplicationController = this.getAppById(id)!
 
-        const entry: ApplicationEntry = applicationController.config.entries[entryKey]!
+    const args = shellwords.split(rawCommand)
+    const parsed = yargsParser(args)
+    const command: string = parsed._[0]
 
-        await this.execAppCommand(applicationController.id, entry.command)
+    if (
+      applicationController.config.commands &&
+      !applicationController.config.commands.hasOwnProperty(command)
+    ) {
+      throw Error(
+        `App command "${command}" is not defined in ${id} application`,
+      )
     }
 
-    /**
-     * Run app command
-     *
-     * @param id
-     * @param command
-     */
-    public async execAppCommand(id: string, command: string): Promise<CommandOutput> {
-        if (!this.isAppDefined(id)) {
-            throw Error(`App "${id}" is not defined`);
-        }
-
-        const applicationController: IApplicationController = this.apps.get(id)!
+    const commandFn: any = applicationController.config.commands![command]
 
-        const commandSplit: string[] = command.split(" ")
-        const baseCommand = commandSplit[0] as keyof typeof applicationController.config.commands
-
-        if (applicationController.config.commands && !applicationController.config.commands.hasOwnProperty(baseCommand)) {
-            throw Error(`App command "${command}" is not defined in ${id} application`);
-        }
+    const commandOutput = await commandFn(
+      applicationController,
+      parsed,
+    )
 
-        const commandFn: any = applicationController.config.commands![baseCommand]
-        const commandOutput = await commandFn(applicationController, commandSplit.slice(1))
+    applicationController.setRunning(true)
 
-        applicationController.setRunning(true)
+    return commandOutput
+  }
 
-        return commandOutput;
+  /**
+   * Close application
+   *
+   * @param id
+   */
+  public closeApp(id: string) {
+    if (!this.isAppDefined(id)) {
+      throw Error(`App "${id}" is not defined`)
     }
 
-    /**
-     * Close application
-     *
-     * @param id
-     */
-    public closeApp(id: string) {
-        if (!this.isAppDefined(id)) {
-            throw Error(`App "${id}" is not defined`);
-        }
+    const applicationController: IApplicationController = this.getAppById(id)!
+
+    applicationController.closeAllWindows()
+    applicationController.setRunning(false)
+  }
+
+  /**
+   * Array of available menu entries for system bars, docks
+   */
+  public get appsEntries() {
+    const entries: Reactive<ApplicationEntryWithInherited[]> = reactive([])
+
+    for (const applicationController of this.apps.values()) {
+      if (!applicationController.config.entries) {
+        continue
+      }
+
+      for (const entryKey of Object.keys(
+        applicationController.config.entries,
+      )) {
+        const entry: ApplicationEntry =
+          applicationController.config.entries[entryKey]!
+
+        entries.push({
+          application: applicationController,
+          title:
+            entry.title !== undefined
+              ? entry.title
+              : applicationController.config.title,
+          icon:
+            entry.icon !== undefined
+              ? entry.icon
+              : applicationController.config.icon,
+          category:
+            entry.category !== undefined
+              ? entry.category
+              : applicationController.config.category,
+          visibility: entry.visibility ?? 'primary',
+          command: entry.command,
+        })
+      }
+    }
 
-        const applicationController: IApplicationController = this.apps.get(id)!
+    return entries
+  }
 
-        applicationController.closeAllWindows()
-        applicationController.setRunning(false)
-    }
+  /**
+   * Array of opened windows for system bars, docks
+   */
+  public get windowsOpened() {
+    const windows: Reactive<Map<string, IWindowController>[]> = reactive([])
 
-    /**
-     * Array of available menu entries for system bars, docks
-     */
-    public get appsEntries() {
-        const entries: Reactive<ApplicationEntryWithInherited[]> = reactive([])
-
-        for (const applicationController of this.apps.values()) {
-            if (!applicationController.config.entries) {
-                continue
-            }
-
-            for (const entryKey of Object.keys(applicationController.config.entries)) {
-                const entry: ApplicationEntry = applicationController.config.entries[entryKey]!
-
-                entries.push({
-                    application: applicationController,
-                    title: entry.title !== undefined ? entry.title : applicationController.config.title,
-                    icon: entry.icon !== undefined ? entry.icon : applicationController.config.icon,
-                    category: entry.category !== undefined ? entry.category : applicationController.config.category,
-                    visibility: entry.visibility ?? 'primary',
-                    command: entry.command
-                })
-            }
-        }
-
-        return entries
+    for (const applicationController of this.apps.values()) {
+      if (applicationController.isRunning) {
+        windows.push(...applicationController.windows)
+      }
     }
 
-    /**
-     * Array of opened windows for system bars, docks
-     */
-    public get windowsOpened() {
-        const windows: Reactive<Map<string, IWindowController>[]> = reactive([])
+    return windows
+  }
 
-        for (const applicationController of this.apps.values()) {
-            if (applicationController.isRunning) {
-                windows.push(...applicationController.windows)
-            }
-        }
+  /**
+   * Array of opened windows for system bars, docks
+   */
+  public get appsRunning() {
+    const applications: Reactive<IApplicationController[]> = reactive([])
 
-        return windows
+    for (const applicationController of this.apps.values()) {
+      if (applicationController.isRunning) {
+        applications.push(applicationController)
+      }
     }
 
-    /**
-     * Array of opened windows for system bars, docks
-     */
-    public get appsRunning() {
-        const applications: Reactive<IApplicationController[]> = reactive([])
+    return applications
+  }
 
-        for (const applicationController of this.apps.values()) {
-            if (applicationController.isRunning) {
-                applications.push(applicationController)
-            }
-        }
+  public getWindowOpenedId(windowId: string) {
+    const mapWindowFound: Map<string, IWindowController> | undefined =
+      this.windowsOpened.find((window: any) => {
+        return window[1].state.id === windowId
+      })
 
-        return applications
+    if (mapWindowFound) {
+      // @ts-ignore
+      return mapWindowFound[1] as IWindowController
     }
-
-    public getWindowOpenedId(windowId: string) {
-        const mapWindowFound: Map<string, IWindowController> | undefined = this.windowsOpened.find((window: any) => {
-            return window[1].state.id === windowId
-        })
-
-        if (mapWindowFound) {
-            // @ts-ignore
-            return mapWindowFound[1] as IWindowController
-        }
+  }
+
+  /**
+   * Gets all unique categories from the installed apps
+   */
+  public get appCategories(): string[] {
+    const categories = new Set<string>()
+
+    for (const applicationController of this.apps.values()) {
+      if (applicationController.config.category) {
+        categories.add(applicationController.config.category)
+      }
     }
-
-    /**
-     * Gets all unique categories from the installed apps
-     */
-    public get appCategories(): string[] {
-        const categories = new Set<string>()
-
-        for (const applicationController of this.apps.values()) {
-            if (applicationController.config.category) {
-                categories.add(applicationController.config.category)
-            }
-        }
-        return Array.from(categories).sort()
+    return Array.from(categories).sort()
+  }
+
+  /**
+   * Gets the apps ordered by category
+   */
+  public get appsByCategory(): {
+    [category: string]: IApplicationController[]
+  } {
+    const categorizedApps: {
+      [category: string]: IApplicationController[]
+    } = {}
+
+    for (const applicationController of this.apps.values()) {
+      const category = applicationController.config.category || 'other'
+      if (!categorizedApps[category]) {
+        categorizedApps[category] = []
+      }
+      categorizedApps[category].push(applicationController)
     }
 
-    /**
-     * Gets the apps ordered by category
-     */
-    public get appsByCategory(): { [category: string]: IApplicationController[] } {
-        const categorizedApps: { [category: string]: IApplicationController[] } = {}
-
-        for (const applicationController of this.apps.values()) {
-            const category = applicationController.config.category || 'other'
-            if (!categorizedApps[category]) {
-                categorizedApps[category] = []
-            }
-            categorizedApps[category].push(applicationController)
-        }
-
-        for (const category in categorizedApps) {
-            categorizedApps[category]!.sort(
-                (a, b) => a.config.title.localeCompare(b.config.title)
-            )
-        }
-
-        return categorizedApps
+    for (const category in categorizedApps) {
+      categorizedApps[category]!.sort((a, b) =>
+        a.config.title.localeCompare(b.config.title),
+      )
     }
+
+    return categorizedApps
+  }
 }

package/runtime/core/managers/DesktopManager.ts

@@ -1,37 +1,47 @@
-import {deepMerge} from "../../utils/utilCommon"
-
 export class DesktopManager {
-    public config: DesktopConfig = {} as DesktopConfig
+  private defaultApps: DefaultAppsConfig = {}
 
-    private defaultApps: DefaultAppsConfig = {}
+  constructor() {}
 
-    constructor() {
+  get config(): DesktopConfig {
+    const runtimeConfig = useRuntimeConfig()
 
-    }
+    return runtimeConfig.public.desktop
+  }
 
-    public hasFeature(featureName: string) {
-        return this.config.features?.indexOf(featureName) !== -1
-    }
+  public hasFeature(featureName: string) {
+    return this.config.features?.indexOf(featureName) !== -1
+  }
 
-    public setConfig(config: DesktopConfig) {
-        this.config = deepMerge(this.config, config) as DesktopConfig
-        this.loadDefaultAppsFromConfig()
-    }
+  public setConfig(config: DesktopConfig) {
+    const runtimeConfig = useRuntimeConfig()
 
-    public setDefaultApp(feature: string, application: IApplicationController, entry: ApplicationEntry) {
-        this.defaultApps[feature] = {
-            application,
-            entry
-        }
-    }
+    runtimeConfig.public.desktop = deepMerge(
+      runtimeConfig.public.desktop,
+      config
+    ) as DesktopConfig
+
+    this.loadDefaultAppsFromConfig()
+  }
 
-    public getDefaultApp(feature: string): DefaultAppConfig {
-        return this.defaultApps[feature] as DefaultAppConfig
+  public setDefaultApp(
+    feature: string,
+    application: IApplicationController,
+    command: string,
+  ) {
+    this.defaultApps[feature] = {
+      application,
+      command,
     }
+  }
+
+  public getDefaultApp(feature: string): DefaultAppConfig {
+    return this.defaultApps[feature] as DefaultAppConfig
+  }
 
-    private loadDefaultAppsFromConfig() {
-        if (this.config.defaultApps) {
-            this.defaultApps = {...this.config.defaultApps}
-        }
+  private loadDefaultAppsFromConfig() {
+    if (this.config.defaultApps) {
+      this.defaultApps = { ...this.config.defaultApps }
     }
+  }
 }

package/runtime/core/managers/TerminalManager.ts

@@ -1,44 +1,48 @@
-import {useApplicationManager} from "../../composables/useApplicationManager"
-import {debugLog} from "../../utils/utilDebug"
+import { useApplicationManager } from '../../composables/useApplicationManager'
+import { debugLog } from '../../utils/utilDebug'
 
 export class TerminalManager {
-    private commands: Map<string, TerminalCommand> = new Map()
-
-    constructor() {
+  private commands: Map<string, TerminalCommand> = new Map()
+
+  constructor() {}
+
+  public addCommand(command: TerminalCommand) {
+    for (const existingCommand of this.commands.keys()) {
+      if (
+        existingCommand.startsWith(command.name) ||
+        command.name.startsWith(existingCommand)
+      ) {
+        throw new Error(`Command prefix conflict with "${existingCommand}"`)
+      }
     }
 
-    public addCommand(command: TerminalCommand) {
-        for (const existingCommand of this.commands.keys()) {
-            if (existingCommand.startsWith(command.name) || command.name.startsWith(existingCommand)) {
-                throw new Error(`Command prefix conflict with "${existingCommand}"`)
-            }
-        }
-
-        this.commands.set(command.name, command)
-        debugLog(`Registered terminal command: ${command.name} → ${command.applicationId}`)
-    }
+    this.commands.set(command.name, command)
+    debugLog(
+      `Registered terminal command: ${command.name} → ${command.applicationId}`,
+    )
+  }
 
-    public listCommands(): string[] {
-        return Array.from(this.commands.keys())
-    }
+  public listCommands(): string[] {
+    return Array.from(this.commands.keys())
+  }
 
-    public async execCommand(input: string): Promise<CommandOutput | void> {
-        const applicationManager = useApplicationManager()
+  public async execCommand(input: string): Promise<CommandOutput | void> {
+    const applicationManager = useApplicationManager()
 
-        const [name, ...args] = input.trim().split(/\s+/)
+    const [name, ...args] = input.trim().split(/\s+/)
 
-        if (!name) {
-            return
-        }
+    if (!name) {
+      return
+    }
 
-        if (!this.commands.has(name)) {
-            return {
-              message: `Command "${name}" not found`
-            }
-        }
+    if (!this.commands.has(name)) {
+      return {
+        message: `Command "${name}" not found`,
+      }
+    }
 
-        const application = this.commands.get(name)!
+    const application = this.commands.get(name)!
 
-        return applicationManager.execAppCommand(application.applicationId, input)
-    }
+    return applicationManager.execAppCommand(application.applicationId, input)
+  }
 }

package/runtime/plugins/resize.client.ts

@@ -1,6 +1,6 @@
 import VueResizable from 'vue-resizable/src/components/vue-resizable.vue'
-import {defineNuxtPlugin} from "nuxt/app"
+import { defineNuxtPlugin } from 'nuxt/app'
 
-export default defineNuxtPlugin(nuxtApp => {
-    nuxtApp.vueApp.component('vue-resizable', VueResizable)
-})
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.component('vue-resizable', VueResizable)
+})