@owdproject/core 3.0.0-alpha.0

package/runtime/stores/storeDesktop.ts

@@ -0,0 +1,39 @@
+import {defineStore} from "pinia"
+import {ref} from "@vue/reactivity"
+
+export const useDesktopStore = defineStore('owd/desktop', () => {
+    const state = ref<{
+        workspace: {
+            overview: boolean
+            active: string
+            list: string[]
+        }
+        volume: {
+            master: number
+        }
+        window: {
+            positionZ: number
+        }
+    }>({
+        workspace: {
+            overview: false,
+            active: '',
+            list: [],
+        },
+        volume: {
+            master: 100,
+        },
+        window: {
+            positionZ: 10
+        }
+    })
+
+    return {
+        state
+    }
+}, {
+    // @ts-expect-error
+    persistedState: {
+        persist: true
+    },
+})

package/runtime/stores/storeDesktopVolume.ts

@@ -0,0 +1,17 @@
+import {defineStore} from "pinia"
+import {computed} from "@vue/reactivity"
+import {useDesktopStore} from "../stores/storeDesktop"
+
+export const useDesktopVolumeStore = defineStore('owd/desktop/volume', () => {
+    const desktopStore = useDesktopStore()
+
+    const master = computed(() => desktopStore.state.volume.master)
+
+    function setMasterVolume(value: number) {
+        desktopStore.state.volume.master = value
+    }
+
+    return {
+        master
+    }
+})

package/runtime/stores/storeDesktopWindow.ts

@@ -0,0 +1,20 @@
+import {defineStore} from "pinia"
+import {computed} from "@vue/reactivity"
+import {useDesktopStore} from "../stores/storeDesktop"
+
+export const useDesktopWindowStore = defineStore('owd/desktop/window', () => {
+    const desktopStore = useDesktopStore()
+
+    const positionZ = computed(() => desktopStore.state.window.positionZ)
+
+    function incrementPositionZ() {
+        desktopStore.state.window.positionZ++
+
+        return desktopStore.state.window.positionZ
+    }
+
+    return {
+        positionZ,
+        incrementPositionZ
+    }
+})

package/runtime/stores/storeDesktopWorkspace.ts

@@ -0,0 +1,59 @@
+import {defineStore} from "pinia"
+import {computed} from "@vue/reactivity"
+import {nanoid} from "nanoid";
+import {useDesktopStore} from "../stores/storeDesktop"
+
+export const useDesktopWorkspaceStore = defineStore('owd/desktop/workspace', () => {
+    const desktopStore = useDesktopStore()
+
+    const active = computed(() => {
+        return desktopStore.state.workspace.active
+    })
+
+    const overview = computed(() => {
+        return desktopStore.state.workspace.overview
+    })
+
+    const list = computed(() => {
+        return desktopStore.state.workspace.list
+    })
+
+    function setupWorkspaces() {
+        if (desktopStore.state.workspace.list.length === 0) {
+            createWorkspace()
+            desktopStore.state.workspace.active = desktopStore.state.workspace.list[0] as string
+        }
+
+        if (desktopStore.state.workspace.list.length === 1) {
+            createWorkspace()
+        }
+    }
+
+    function setOverview(value: boolean) {
+        desktopStore.state.workspace.overview = value
+    }
+
+    function setWorkspace(value: string) {
+        desktopStore.state.workspace.active = value
+    }
+
+    function createWorkspace() {
+        desktopStore.state.workspace.list.push(nanoid(8))
+    }
+
+    const workspaceActiveIndex = computed(() => {
+        return desktopStore.state.workspace.list.findIndex(
+            workspace => workspace === desktopStore.state.workspace.active
+        )
+    })
+
+    return {
+        active,
+        overview,
+        list,
+        workspaceActiveIndex,
+        setupWorkspaces,
+        setOverview,
+        setWorkspace,
+    }
+})

package/runtime/utils/utilsCommon.ts

@@ -0,0 +1,35 @@
+export function deepClone(obj: any) {
+    return JSON.parse(JSON.stringify(obj))
+}
+
+export function deepMerge<T>(target: T, source: Partial<T>): T {
+    function isObject(value: any): value is Record<string, any> {
+        return (
+            value !== null &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            !(value instanceof Date) &&
+            !(value instanceof RegExp)
+        )
+    }
+
+    if (isObject(target) && isObject(source)) {
+        const result = { ...target }
+
+        for (const key in source) {
+            const targetValue = (target as any)[key]
+            const sourceValue = (source as any)[key]
+
+            if (isObject(sourceValue) && isObject(targetValue)) {
+                // @ts-ignore
+                result[key] = deepMerge(targetValue, sourceValue)
+            } else {
+                result[key] = sourceValue
+            }
+        }
+
+        return result
+    }
+
+    return source as T
+}

package/runtime/utils/utilsDebug.ts

@@ -0,0 +1,30 @@
+export function isDebugMode() {
+    return import.meta.env.MODE === 'development'
+}
+
+export function debugLog(...messages: any[]) {
+    if (!isDebugMode()) {
+        return false;
+    }
+
+    console.log(`[OWD]`, ...messages);
+    return true
+}
+
+export function debugWarn(...messages: any[]) {
+    if (!isDebugMode()) {
+        return false;
+    }
+
+    console.warn(`[OWD]`, ...messages);
+    return true
+}
+
+export function debugError(...messages: any[]) {
+    if (!isDebugMode()) {
+        return false;
+    }
+
+    console.error(`[OWD]`, ...messages);
+    return true
+}

package/runtime/utils/utilsDesktop.ts

@@ -0,0 +1,12 @@
+import {useApplicationManager} from "../composables/useApplicationManager";
+import {useDesktopManager} from "../composables/useDesktopManager";
+
+export function defineDesktopApp(config: ApplicationConfig) {
+    const applicationManager = useApplicationManager()
+    return applicationManager.defineApp(config.id, config)
+}
+
+export function defineDesktopConfig(config: DesktopConfig) {
+    const desktopManager = useDesktopManager()
+    desktopManager.setConfig(config)
+}

package/runtime/utils/utilsTerminal.ts

@@ -0,0 +1,5 @@
+export function parseInput(input: string): { command: string; args: string[] } | null {
+    const match = input.match(/(?:[^\s"]+|"[^"]*")+/g)
+    if (!match) return null
+    return { command: match[0], args: match.slice(1).map(arg => arg.replace(/"/g, "")) }
+}

package/runtime/utils/utilsWindow.ts

@@ -0,0 +1,14 @@
+// support for controller-less windows
+// (for example: dummy windows in docs)
+export function handleWindowControllerProps(windowController: any) {
+    if (windowController.instanced) {
+        return windowController
+    }
+
+    return {
+        ...windowController,
+        state: {
+            ...windowController.config,
+        },
+    }
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../.nuxt/tsconfig.json",
+}

package/types/index.d.ts

@@ -0,0 +1,9 @@
+declare module 'nuxt/schema' {
+  interface AppConfig {
+    owd: {
+      apps: string[]
+    }
+  }
+}
+
+export {}

package/types/owd.d.ts

@@ -0,0 +1,313 @@
+interface IApplicationManager {
+    apps: Map<string, IApplicationController>
+    appsRunning: Reactive<IApplicationController>
+
+    importApps()
+
+    get appsEntries(): Reactive<ApplicationEntry[]>
+    get windowsOpened(): Reactive<IWindowController>
+    get appCategories(): string[]
+    get appsByCategory(): { [category: string]: IApplicationController[] }
+
+    defineApp(appId: string, config: ApplicationConfig): Promise<IApplicationController>
+    closeApp(id: string): void
+
+    execAppCommand(appId: string, command: string): Promise<IApplicationController | undefined>
+
+    isAppDefined(id: string): boolean
+    isAppRunning(id: string): boolean
+}
+
+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>
+}
+
+interface ApplicationConfigProvide {
+    name: string
+    entry: string
+}
+
+type IApplicationMeta = { [key: string]: any }
+
+interface IApplicationController {
+    id: string
+    config: ApplicationConfig
+    get meta(): { [key: string]: any }
+    store: Pinia
+    windows: Reactive<Map<string, IWindowController>>
+
+    isRunning: boolean
+    setRunning(value: boolean): void
+
+    initApplication(): Promise<void>
+    restoreApplication(): Promise<boolean>
+
+    openWindow(model: string, windowStoredState?: WindowStoredState, meta?: {
+        isRestoring?: boolean
+    })
+
+    closeWindow(windowId: string): void
+    closeAllWindows(): void
+
+    get windowsOpened(): Reactive<Map<string, IWindowController>>
+}
+
+interface IWindowController {
+    application: IApplicationController
+    instanced: boolean
+    model: string
+
+    config: WindowConfig
+    override: WindowOverride
+    get state(): WindowState
+
+    // common
+    get title(): string
+    get icon(): string|undefined
+
+    // sizes
+    get width(): WindowSizeValue
+
+    get maxWidth(): WindowSizeValue
+
+    get minWidth(): WindowSizeValue
+
+    get height(): WindowSizeValue
+
+    get maxHeight(): WindowSizeValue
+
+    get minHeight(): WindowSizeValue
+
+    // minimize
+    get isMinimizable(): boolean
+
+    // maximize
+    get isMaximizable(): boolean
+
+    get isMaximized(): boolean
+
+    // destroy
+    get isDestroyable(): boolean
+
+    // draggable
+    get isDraggable(): boolean
+
+    // resizable
+    get isResizable(): boolean
+
+    get actions(): {
+        // position
+        setActive(value: boolean)
+        setFocus(value: boolean)
+        bringToFront()
+        setPosition(data: WindowPosition)
+
+        // size
+        setSize(data: WindowSize)
+
+        // minimize
+        minimize(): boolean
+
+        // maximize
+        toggleMaximize(): boolean
+        maximize(): boolean
+        unmaximize(): boolean
+
+        // destroy
+        destroy(): boolean
+
+        // workspace
+        setWorkspace(workspaceId: string)
+
+        // override
+        setTitleOverride(title: string|undefined): void
+        resetTitleOverride(): void
+    }
+}
+
+interface WindowContent {
+    padded?: boolean
+    centered?: boolean
+}
+
+interface WindowConfig {
+    title?: string
+    category?: string
+    icon?: string
+    pinned?: boolean
+
+    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
+}
+
+interface WindowStoredState {
+    model: string,
+    state: WindowState
+}
+
+interface WindowOverride {
+    title?: undefined|string
+    icon?: undefined|string
+}
+
+interface WindowState {
+    id: string
+    createdAt: number
+
+    category?: string
+    pinned?: boolean
+    workspace: string
+
+    // position
+    position?: WindowPosition
+
+    // sizes
+    size?: WindowSize
+
+    // focused
+    focused: boolean
+
+    // minimize
+    active?: boolean
+    minimizable?: boolean
+
+    // maximize
+    maximized?: boolean
+    maximizable?: boolean
+
+    // destroy
+    destroyable?: boolean
+
+    // draggable
+    draggable?: boolean
+
+    // draggable
+    resizable?: boolean
+}
+
+interface WindowSize {
+    width?: WindowSizeValue
+    height?: WindowSizeValue
+    minWidth?: WindowSizeValue
+    minHeight?: WindowSizeValue
+    maxWidth?: WindowSizeValue
+    maxHeight?: WindowSizeValue
+}
+
+interface WindowPosition {
+    x?: number
+    y?: number
+    z?: number
+}
+
+type WindowSizeValue = number|string|undefined
+
+interface ApplicationEntry {
+    title?: string
+    icon?: string
+    category?: string
+    command: string | any
+}
+
+interface ApplicationEntryWithInherited extends ApplicationEntry {
+    application: IApplicationController
+}
+
+// DESKTOP
+
+interface IDesktopManager {
+    defaultApps: DefaultAppsConfig
+
+    getDefaultApp(feature: string)
+    setDefaultApp(feature: string, application: IApplicationController, entry: ApplicationEntry)
+}
+
+interface DesktopConfig {
+    name: string
+    compatibility: string
+    defaultApps?: DefaultAppsConfig
+    features?: string[]
+    systemBar?: DesktopSystemBarConfig
+    dockBar?: DesktopDockBarConfig
+}
+
+interface DesktopWindowsConfig {
+    position: 'relative' | 'absolute' | 'fixed'
+}
+
+interface DesktopDockBarConfig {
+    enabled?: boolean
+    position?: 'top' | 'bottom'
+}
+
+interface DesktopSystemBarConfig {
+    enabled?: boolean
+    position?: 'top' | 'bottom'
+    startButton?: boolean
+}
+
+// TERMINAL
+
+interface CommandFn {
+    fn: (app: IApplicationController, args: string[]) => string | CommandOutput | void
+    app: IApplicationController
+}
+
+interface CommandOutput {
+    text: string
+    isError?: boolean
+}
+
+// DEFAULT APP
+
+interface DefaultAppsConfig {
+    terminal?: DefaultAppConfig
+    browser?: DefaultAppConfig
+    editor?: DefaultAppConfig
+    [key: string]: DefaultAppConfig
+}
+
+interface DefaultAppConfig {
+    application: IApplicationController
+    entry: ApplicationEntry
+}