@owdproject/core 3.1.3 → 3.1.4-beta.0

package/types/index.d.ts

@@ -1,283 +1,307 @@
-import type { Nuxt } from '@nuxt/schema';
-import { useApplicationManager } from '../runtime/composables/useApplicationManager';
+import type { Nuxt } from '@nuxt/schema'
+import { useApplicationManager } from '../runtime/composables/useApplicationManager'
 
 declare module 'nuxt/schema' {
   interface PublicRuntimeConfig {
     owd: {
       tailwindPaths: []
-    };
+    }
   }
 }
 
 interface IApplicationManager {
-    apps: Map<string, IApplicationController>
+  apps: Map<string, IApplicationController>
 
-    get appsEntries(): Reactive<ApplicationEntry[]>
+  get appsEntries(): Reactive<ApplicationEntry[]>
 
-    get appsRunning(): Reactive<IApplicationController[]>
+  get appsRunning(): Reactive<IApplicationController[]>
 
-    get windowsOpened(): Reactive<IWindowController[]>
+  get windowsOpened(): Reactive<IWindowController[]>
 
-    get appCategories(): string[]
+  get appCategories(): string[]
 
-    get appsByCategory(): { [category: string]: IApplicationController[] }
+  get appsByCategory(): { [category: string]: IApplicationController[] }
 
-    defineApp(id: string, config: ApplicationConfig): Promise<IApplicationController>
+  defineApp(
+    id: string,
+    config: ApplicationConfig,
+  ): Promise<IApplicationController>
 
-    closeApp(id: string): void
+  closeApp(id: string): void
 
-    launchAppEntry(id: string, entry: string): Promise<IApplicationController | undefined | void>
-    execAppCommand(id: string, command: string, meta: undefined | any): Promise<CommandOutput | void>
+  launchAppEntry(
+    id: string,
+    entry: string,
+  ): Promise<IApplicationController | undefined | void>
+  execAppCommand(
+    id: string,
+    command: string,
+    meta: undefined | any,
+  ): Promise<CommandOutput | void>
 
-    isAppDefined(id: string): boolean
+  isAppDefined(id: string): boolean
 
-    isAppRunning(id: string): boolean
+  isAppRunning(id: string): boolean
 }
 
-type ApplicationCommand = (app: IApplicationController, args: any) => void;
+type ApplicationCommand = (app: IApplicationController, args: any) => void
 
 interface ApplicationConfig {
-    id: string
-    title: string
-    icon?: string
-    category?: string
-    version?: string
-    description?: string
-    provides?: ApplicationConfigProvide
-    singleton?: boolean
-    meta?: IApplicationMeta
-    permissions?: ApplicationPermission[];
-    windows?: { [key: string]: WindowConfig }
-    entries: { [key: string]: ApplicationEntry }
-    commands?: { [key: string]: ApplicationCommand }
-
-    onReady?(app: IApplicationController): void | Promise<void>
-
-    onLaunch?(app: IApplicationController): void | Promise<void>
-
-    onRestore?(app: IApplicationController): void | Promise<void>
-
-    onClose?(app: IApplicationController): void | Promise<void>
+  id: string
+  title: string
+  icon?: string
+  category?: string
+  version?: string
+  description?: string
+  provides?: ApplicationConfigProvide
+  singleton?: boolean
+  meta?: IApplicationMeta
+  permissions?: ApplicationPermission[]
+  windows?: { [key: string]: WindowConfig }
+  entries: { [key: string]: ApplicationEntry }
+  commands?: { [key: string]: ApplicationCommand }
+
+  onReady?(app: IApplicationController): void | Promise<void>
+
+  onLaunch?(app: IApplicationController): void | Promise<void>
+
+  onRestore?(app: IApplicationController): void | Promise<void>
+
+  onClose?(app: IApplicationController): void | Promise<void>
 }
 
 interface ApplicationConfigProvide {
-    name: string
-    entry: string
+  name: string
+  command: string
 }
 
 type IApplicationMeta = { [key: string]: any }
 
 interface IApplicationController {
-    id: string
-    config: ApplicationConfig
+  id: string
+  config: ApplicationConfig
 
-    get meta(): { [key: string]: any }
+  get meta(): { [key: string]: any }
 
-    store: Pinia
-    windows: Reactive<Map<string, IWindowController>>
+  store: Pinia
+  windows: Reactive<Map<string, IWindowController>>
 
-    isRunning: boolean
+  isRunning: boolean
 
-    setRunning(value: boolean): void
+  setRunning(value: boolean): void
 
-    initApplication(): Promise<void>
+  initApplication(): Promise<void>
 
-    restoreApplication(): Promise<boolean>
+  restoreApplication(): Promise<boolean>
 
-    getWindowsByModel(model: string): IWindowController[]
+  getWindowsByModel(model: string): IWindowController[]
 
-    getFirstWindowByModel(model: string): IWindowController | undefined
+  getFirstWindowByModel(model: string): IWindowController | undefined
 
-    openWindow(model: string, windowStoredState?: WindowStoredState, options?: {
-        isRestoring?: boolean
-    })
+  openWindow(
+    model: string,
+    windowStoredState?: WindowStoredState,
+    options?: {
+      isRestoring?: boolean
+    },
+  )
 
-    closeWindow(windowId: string): void
+  closeWindow(windowId: string): void
 
-    closeAllWindows(): void
+  closeAllWindows(): void
 
-    execCommand(command: string): Promise<CommandOutput | void>
+  execCommand(command: string): Promise<CommandOutput | void>
 
-    // deprecated
-    get windowsOpened(): Reactive<Map<string, IWindowController>>
+  // deprecated
+  get windowsOpened(): Reactive<Map<string, IWindowController>>
 }
 
 interface IWindowController {
-    application: IApplicationController
-    instanced: boolean
-    model: string
+  application: IApplicationController
+  instanced: boolean
+  model: string
 
-    config: WindowConfig
-    override: WindowOverride
+  config: WindowConfig
+  override: WindowOverride
 
-    get state(): WindowState
+  get state(): WindowState
 
-    // common
-    get title(): string
+  // common
+  get title(): string
 
-    get icon(): string | undefined
+  get icon(): string | undefined
 
-    // sizes
-    get size(): WindowSize
+  // sizes
+  get size(): WindowSize
 
-    // minimize
-    get isMinimizable(): boolean
+  // minimize
+  get isMinimizable(): boolean
 
-    // maximize
-    get isMaximizable(): boolean
+  // maximize
+  get isMaximizable(): boolean
 
-    get isMaximized(): boolean
+  get isMaximized(): boolean
 
-    // destroy
-    get isDestroyable(): boolean
+  // destroy
+  get isDestroyable(): boolean
 
-    // draggable
-    get isDraggable(): boolean
+  // draggable
+  get isDraggable(): boolean
 
-    // resizable
-    get isResizable(): boolean
+  // resizable
+  get isResizable(): boolean
 
-    get actions(): {
-        // position
-        setActive(value: boolean)
-        setFocus(value: boolean)
-        bringToFront()
-        setPosition(data: WindowPosition)
+  get actions(): {
+    // position
+    setActive(value: boolean)
+    setFocus(value: boolean)
+    bringToFront()
+    setPosition(data: WindowPosition)
 
-        // size
-        setSize(data: WindowSize)
+    // size
+    setSize(data: WindowSize)
 
-        // minimize
-        minimize(): boolean
+    // minimize
+    minimize(): boolean
 
-        // maximize
-        toggleMaximize(): boolean
-        maximize(): boolean
-        unmaximize(): boolean
+    // maximize
+    toggleMaximize(): boolean
+    maximize(): boolean
+    unmaximize(): boolean
 
-        // destroy
-        destroy(): boolean
+    // destroy
+    destroy(): boolean
 
-        // workspace
-        setWorkspace(workspaceId: string)
+    // workspace
+    setWorkspace(workspaceId: string)
 
-        // override
-        setTitleOverride(title: string | undefined): void
-        resetTitleOverride(): void
-    }
+    // override
+    setTitleOverride(title: string | undefined): void
+    resetTitleOverride(): void
+  }
 }
 
 interface WindowContent {
-    padded?: boolean
-    centered?: boolean
+  padded?: boolean
+  centered?: boolean
 }
 
 interface WindowConfig {
-    title?: string
-    category?: string
-    icon?: string
-
-    component?: Raw<Component>
-
-    // position
-    position?: WindowPosition
-
-    // sizes
-    size: WindowSize
-
-    // minimize
-    minimizable?: boolean
-
-    // maximize
-    maximized?: boolean
-    maximizable?: boolean
-
-    // destroy
-    destroyable?: boolean
-
-    // draggable
-    draggable?: boolean
-
-    // draggable
-    resizable?: boolean
-
-    overridable?: Partial<Record<'position' | 'size' | 'maximized' | 'draggable' | 'resizable' | 'destroyable' | 'minimizable', boolean>>
+  title?: string
+  category?: string
+  icon?: string
+
+  component?: Raw<Component>
+
+  // position
+  position?: WindowPosition
+
+  // sizes
+  size: WindowSize
+
+  // minimize
+  minimizable?: boolean
+
+  // maximize
+  maximized?: boolean
+  maximizable?: boolean
+
+  // destroy
+  destroyable?: boolean
+
+  // draggable
+  draggable?: boolean
+
+  // draggable
+  resizable?: boolean
+
+  overridable?: Partial<
+    Record<
+      | 'position'
+      | 'size'
+      | 'maximized'
+      | 'draggable'
+      | 'resizable'
+      | 'destroyable'
+      | 'minimizable',
+      boolean
+    >
+  >
 }
 
 interface WindowStoredState {
-    model: string,
-    state: WindowState
-    meta: any
+  model: string
+  state: WindowState
+  meta: any
 }
 
 interface WindowOverride {
-    title?: undefined | string
-    icon?: undefined | string
+  title?: undefined | string
+  icon?: undefined | string
 }
 
 interface WindowState {
-    id: string
-    createdAt: number
+  id: string
+  createdAt: number
 
-    category?: string
-    workspace: string
+  category?: string
+  workspace: string
 
-    // position
-    position?: WindowPosition
+  // position
+  position?: WindowPosition
 
-    // sizes
-    size?: WindowSize
+  // sizes
+  size?: WindowSize
 
-    // focused
-    focused: boolean
+  // focused
+  focused: boolean
 
-    // minimize
-    active?: boolean
-    minimizable?: boolean
+  // minimize
+  active?: boolean
+  minimizable?: boolean
 
-    // maximize
-    maximized?: boolean
-    maximizable?: boolean
+  // maximize
+  maximized?: boolean
+  maximizable?: boolean
 
-    // destroy
-    destroyable?: boolean
+  // destroy
+  destroyable?: boolean
 
-    // draggable
-    draggable?: boolean
+  // draggable
+  draggable?: boolean
 
-    // draggable
-    resizable?: boolean
+  // draggable
+  resizable?: boolean
 }
 
 interface WindowSize {
-    width?: WindowSizeValue
-    height?: WindowSizeValue
-    minWidth?: WindowSizeValue
-    minHeight?: WindowSizeValue
-    maxWidth?: WindowSizeValue
-    maxHeight?: WindowSizeValue
+  width?: WindowSizeValue
+  height?: WindowSizeValue
+  minWidth?: WindowSizeValue
+  minHeight?: WindowSizeValue
+  maxWidth?: WindowSizeValue
+  maxHeight?: WindowSizeValue
 }
 
 interface WindowPosition {
-    x?: number
-    y?: number
-    z?: number
+  x?: number
+  y?: number
+  z?: number
 }
 
 type WindowSizeValue = number | string | undefined
 
 interface ApplicationEntry {
-    title?: string
-    icon?: string
-    category?: string
-    visibility?: ApplicationEntryVisibility
-    command: string | any
+  title?: string
+  icon?: string
+  category?: string
+  visibility?: ApplicationEntryVisibility
+  command: string | any
 }
 
-
 interface ApplicationEntryWithInherited extends ApplicationEntry {
-    application: IApplicationController
-    visibility: ApplicationEntryVisibility
+  application: IApplicationController
+  visibility: ApplicationEntryVisibility
 }
 
 type ApplicationEntryVisibility = 'primary' | 'secondary' | 'hidden'
@@ -285,75 +309,79 @@ type ApplicationEntryVisibility = 'primary' | 'secondary' | 'hidden'
 // DESKTOP
 
 interface IDesktopManager {
-    defaultApps: DefaultAppsConfig
+  defaultApps: DefaultAppsConfig
 
-    getDefaultApp(feature: string)
+  getDefaultApp(feature: string)
 
-    setDefaultApp(feature: string, application: IApplicationController, entry: ApplicationEntry)
+  setDefaultApp(
+    feature: string,
+    application: IApplicationController,
+    command: ApplicationCommand,
+  )
 }
 
 interface DesktopConfig {
-    theme?: string
-    modules?: string[]
-    apps?: string[]
+  theme?: string
+  modules?: string[]
+  apps?: string[]
 
-    name?: string
-    defaultApps?: DefaultAppsConfig
-    features?: string[]
+  name?: stringThis
+  defaultApps?: DefaultAppsConfig
+  features?: string[]
 
-    systemBar?: DesktopSystemBarConfig
-    dockBar?: DesktopDockBarConfig
-    workspaces?: DesktopWorkspacesConfig
+  systemBar?: DesktopSystemBarConfig
+  dockBar?: DesktopDockBarConfig
+  workspaces?: DesktopWorkspacesConfig
 }
 
 interface DesktopWindowsConfig {
-    position: 'relative' | 'absolute' | 'fixed'
+  position: 'relative' | 'absolute' | 'fixed'
 }
 
 interface DesktopDockBarConfig {
-    enabled?: boolean
-    position?: 'top' | 'bottom'
+  enabled?: boolean
+  position?: 'top' | 'bottom'
 }
 
 interface DesktopSystemBarConfig {
-    enabled?: boolean
-    position?: 'top' | 'bottom'
-    startButton?: boolean
+  enabled?: boolean
+  position?: 'top' | 'bottom'
+  startButton?: boolean
 }
 
 interface DesktopWorkspacesConfig {
-    enabled?: boolean
+  enabled?: boolean
 }
 
 // TERMINAL
 
 type TerminalCommand = {
-    name: string
-    applicationId: string
+  name: string
+  applicationId: string
 }
 
 interface CommandOutput {
-    text: string
-    isError?: boolean
+  text: string
+  isError?: boolean
 }
 
 // DEFAULT APP
 
 interface DefaultAppsConfig {
-    terminal?: DefaultAppConfig
-    browser?: DefaultAppConfig
-    editor?: DefaultAppConfig
+  terminal?: DefaultAppConfig
+  browser?: DefaultAppConfig
+  editor?: DefaultAppConfig
 
-    [key: string]: DefaultAppConfig
+  [key: string]: DefaultAppConfig
 }
 
 interface DefaultAppConfig {
-    application: IApplicationController
-    entry: ApplicationEntry
+  application: IApplicationController
+  entry: ApplicationEntry
 }
 
 export function defineDesktopApp(config: ApplicationConfig)
 export function defineDesktopConfig(config: DesktopConfig)
-export function registerTailwindPath(nuxt: Nuxt, path: string): void;
+export function registerTailwindPath(nuxt: Nuxt, path: string): void
 
 export {}

package/vitest.config.ts

@@ -1,6 +1,6 @@
 /// <reference types='vitest' />
-import { defineConfig } from 'vite';
-import vue from '@vitejs/plugin-vue';
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
 
 export default defineConfig(() => ({
   root: __dirname,
@@ -21,4 +21,4 @@ export default defineConfig(() => ({
       provider: 'v8' as const,
     },
   },
-}));
+}))

package/eslint.config.mjs

@@ -1,30 +0,0 @@
-import { FlatCompat } from '@eslint/eslintrc';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import js from '@eslint/js';
-import baseConfig from '../../eslint.config.mjs';
-const compat = new FlatCompat({
-  baseDirectory: dirname(fileURLToPath(import.meta.url)),
-  recommendedConfig: js.configs.recommended,
-});
-
-export default [
-  ...baseConfig,
-  {
-    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.vue'],
-    // Override or add rules here
-    rules: {},
-  },
-  //...compat.extends('@nuxt/eslint-config'),
-  {
-    files: ['**/*.vue'],
-    languageOptions: {
-      parserOptions: {
-        parser: await import('@typescript-eslint/parser'),
-      },
-    },
-  },
-  {
-    ignores: ['.nuxt/**', '.output/**', 'node_modules'],
-  },
-];

package/runtime/composables/useAppEntries.ts

@@ -1,36 +0,0 @@
-import {useApplicationManager} from './useApplicationManager'
-import {computed} from "@vue/reactivity"
-
-type SortBy = 'title' | 'category' | ((a: ApplicationEntryWithInherited, b: ApplicationEntryWithInherited) => number)
-type Visibility = 'primary' | 'all' | ((entry: ApplicationEntryWithInherited) => boolean)
-
-export function useAppEntries() {
-    const applicationManager = useApplicationManager()
-
-    const sortedAppEntries = function(
-        sortBy: SortBy = 'title',
-        visibility: Visibility = 'primary'
-    ): Ref<ApplicationEntryWithInherited[]> {
-        return computed(() => {
-            const currentEntries = [...applicationManager.appsEntries]
-
-            // filtering
-            const filtered = typeof visibility === 'function'
-                ? currentEntries.filter(visibility)
-                : visibility === 'primary'
-                    ? currentEntries.filter(e => e.visibility !== 'secondary')
-                    : currentEntries
-
-            // sorting
-            const sorted = typeof sortBy === 'function'
-                ? filtered.sort(sortBy)
-                : sortBy === 'title'
-                    ? filtered.sort((a, b) => (a.title || '').localeCompare(b.title || ''))
-                    : filtered.sort((a, b) => (a.category || '').localeCompare(b.category || ''))
-
-            return sorted
-        })
-    }
-
-    return { sortedAppEntries }
-}