@owdproject/core 3.1.3 → 3.1.4-beta.0

package/runtime/stores/storeApplication.ts

@@ -0,0 +1,235 @@
+import { defineStore } from 'pinia'
+import { reactive, ref, computed } from 'vue'
+import { nanoid } from 'nanoid'
+import { WindowController } from '../core/controllers/WindowController'
+import { useApplicationManager } from '../composables/useApplicationManager'
+import { useApplicationWindowsStore } from './storeApplicationWindows'
+import { useApplicationMetaStore } from './storeApplicationMeta'
+import { useTerminalManager } from '../composables/useTerminalManager'
+import { useDesktopManager } from '../composables/useDesktopManager'
+import { useDesktopWorkspaceStore } from './storeDesktopWorkspace'
+import { debugLog, debugError } from '../utils/utilDebug'
+
+interface WindowStoredState {
+  model: string
+  state: any
+  meta?: any
+}
+
+export const useApplicationStore = function(applicationId: string, applicationConfig: ApplicationConfig) {
+  return defineStore(`owd/application/${applicationId}`, () => {
+    // reactive state
+    const windows = reactive(new Map<string, WindowController>())
+    const isRunning = ref<boolean>(false)
+
+    // composables e stores esterni
+    const applicationManager = useApplicationManager()
+    const terminalManager = useTerminalManager()
+    const desktopManager = useDesktopManager()
+    const desktopWorkspaceStore = useDesktopWorkspaceStore()
+
+    // stores figli
+    let storeWindows: ReturnType<typeof useApplicationWindowsStore>
+    let storeMeta: ReturnType<typeof useApplicationMetaStore>
+
+    // init application
+    async function initApplication() {
+      storeWindows = useApplicationWindowsStore(applicationId)
+      storeMeta = useApplicationMetaStore(applicationId)
+
+      // Fornisci applicazione di default se presente
+      if (applicationConfig.provides) {
+        const existingDefault = desktopManager.getDefaultApp(
+          applicationConfig.provides.name,
+        )
+        if (!existingDefault) {
+          desktopManager.setDefaultApp(
+            applicationConfig.provides.name,
+            store, // store o qualcosa che rappresenta questa app?
+            applicationConfig.entries![applicationConfig.provides.entry]!,
+          )
+          debugLog(
+            `${applicationConfig.title} set as predefined app for "${applicationConfig.provides.name}"`,
+          )
+        }
+      }
+
+      // registra comandi terminale
+      if (applicationConfig.commands) {
+        for (const commandKey of Object.keys(applicationConfig.commands)) {
+          terminalManager.addCommand({
+            applicationId,
+            name: commandKey,
+          })
+        }
+      }
+
+      if (storeWindows.$persistedState) await storeWindows.$persistedState.isReady()
+      if (storeMeta.$persistedState) await storeMeta.$persistedState.isReady()
+
+      await restoreApplication()
+
+      if (typeof applicationConfig.onReady === 'function') {
+        applicationConfig.onReady(store)
+      }
+    }
+
+    // restore
+    async function restoreApplication() {
+      if (typeof applicationConfig.onRestore === 'function') {
+        await applicationConfig.onRestore(store)
+      }
+
+      if (!storeWindows.windows || Object.keys(storeWindows.windows).length === 0) {
+        return false
+      }
+
+      restoreWindows()
+      setRunning(true)
+      return true
+    }
+
+    function restoreWindows() {
+      Object.keys(storeWindows.windows).forEach((windowId) => {
+        const windowStore = storeWindows.windows[windowId]
+        if (windowStore) {
+          openWindow(windowStore.model, windowStore, { isRestoring: true })
+        }
+      })
+      debugLog('Windows restored', windows)
+    }
+
+    // open window
+    function openWindow(
+      model: string,
+      windowStoredState?: WindowStoredState,
+      meta?: any,
+    ): WindowController | undefined {
+      if (!applicationConfig.windows || !applicationConfig.windows.hasOwnProperty(model)) {
+        debugError(`Window model "${model}" not found`)
+        return
+      }
+
+      let windowId: string
+
+      if (!windowStoredState) {
+        windowId = `${model}-${nanoid(6)}`
+        const windowConfig = applicationConfig.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
+
+        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 = storeWindows.windows[windowId]
+      } else {
+        windowId = windowStoredState.state.id
+      }
+
+      const windowConfig = applicationConfig.windows[model] as WindowConfig
+      const windowController = new WindowController(store, model, windowConfig, windowStoredState!)
+
+      if (!meta?.isRestoring) {
+        windowController.actions.bringToFront()
+      }
+
+      windows.set(windowId, windowController)
+      setRunning(true)
+
+      return windowController
+    }
+
+    // close window
+    function closeWindow(windowId: string) {
+      delete storeWindows.windows[windowId]
+      windows.delete(windowId)
+
+      if (windows.size === 0) {
+        applicationManager.closeApp(applicationId)
+      }
+    }
+
+    // close all windows
+    function closeAllWindows() {
+      storeWindows.windows = {}
+      windows.clear()
+    }
+
+    // getters
+    const windowsOpened = computed(() => windows)
+
+    function getWindowById(id: string) {
+      return windows.get(id)
+    }
+
+    function getWindowsByModel(model: string) {
+      return Array.from(windows.values()).filter((w) => w.model === model)
+    }
+
+    function getFirstWindowByModel(model: string) {
+      return Array.from(windows.values()).find((w) => w.model === model)
+    }
+
+    function setRunning(value: boolean) {
+      isRunning.value = value
+    }
+
+    // meta management
+    const meta = computed(() => storeMeta.meta)
+
+    function getMeta(key: string) {
+      return meta.value[key]
+    }
+
+    function setMeta(key: string, value: any) {
+      storeMeta.meta[key] = value
+    }
+
+    // command exec
+    async function execCommand(command: string) {
+      return applicationManager.execAppCommand(applicationId, command)
+    }
+
+    const store = {
+      id: applicationId,
+      config: applicationConfig,
+      storeWindows,
+      storeMeta,
+      windows,
+      isRunning,
+      initApplication,
+      restoreApplication,
+      openWindow,
+      closeWindow,
+      closeAllWindows,
+      windowsOpened,
+      getWindowById,
+      getWindowsByModel,
+      getFirstWindowByModel,
+      setRunning,
+      meta,
+      getMeta,
+      setMeta,
+      execCommand,
+    }
+
+    return store
+  })()
+}

package/runtime/stores/storeApplicationMeta.ts

@@ -1,11 +1,15 @@
-import {defineStore} from "pinia"
+import { defineStore } from 'pinia'
 
 export const useApplicationMetaStore = (appId: string, states: any = {}) => {
-    return defineStore(`owd/application/${appId}/meta`, () => {
-        return states
-    }, {
-        persistedState: {
-            persist: true
-        },
-    })
+  return defineStore(
+    `owd/application/${appId}/meta`,
+    () => {
+      return states
+    },
+    {
+      persistedState: {
+        persist: true,
+      },
+    },
+  )
 }

package/runtime/stores/storeApplicationWindows.ts

@@ -1,16 +1,20 @@
-import {defineStore} from "pinia"
-import {ref} from "vue"
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
 
 export const useApplicationWindowsStore = (appId: string) => {
-    return defineStore(`owd/application/${appId}/windows`, () => {
-        const windows: Ref<{[windowId: string]: WindowStoredState}> = ref({})
+  return defineStore(
+    `owd/application/${appId}/windows`,
+    () => {
+      const windows: Ref<{ [windowId: string]: WindowStoredState }> = ref({})
 
-        return {
-            windows,
-        }
-    }, {
-        persistedState: {
-            persist: true
-        },
-    })()
+      return {
+        windows,
+      }
+    },
+    {
+      persistedState: {
+        persist: true,
+      },
+    },
+  )()
 }

package/runtime/stores/storeDesktop.ts

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

package/runtime/stores/storeDesktopVolume.ts

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

package/runtime/stores/storeDesktopWindow.ts

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

package/runtime/stores/storeDesktopWorkspace.ts

@@ -1,59 +1,63 @@
-import {defineStore} from "pinia"
-import {computed} from "vue"
-import {useDesktopStore} from "./storeDesktop"
-import {nanoid} from "nanoid";
-
-export const useDesktopWorkspaceStore = defineStore('owd/desktop/workspace', () => {
+import { defineStore } from 'pinia'
+import { computed } from 'vue'
+import { useDesktopStore } from './storeDesktop'
+import { nanoid } from 'nanoid'
+
+export const useDesktopWorkspaceStore = defineStore(
+  'owd/desktop/workspace',
+  () => {
     const desktopStore = useDesktopStore()
 
     const active = computed(() => {
-        return desktopStore.state.workspace.active
+      return desktopStore.state.workspace.active
     })
 
     const overview = computed(() => {
-        return desktopStore.state.workspace.overview
+      return desktopStore.state.workspace.overview
     })
 
     const list = computed(() => {
-        return desktopStore.state.workspace.list
+      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()
-        }
+      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
+      desktopStore.state.workspace.overview = value
     }
 
     function setWorkspace(value: string) {
-        desktopStore.state.workspace.active = value
+      desktopStore.state.workspace.active = value
     }
 
     function createWorkspace() {
-        desktopStore.state.workspace.list.push(nanoid(8))
+      desktopStore.state.workspace.list.push(nanoid(8))
     }
 
     const workspaceActiveIndex = computed(() => {
-        return desktopStore.state.workspace.list.findIndex(
-            workspace => workspace === desktopStore.state.workspace.active
-        )
+      return desktopStore.state.workspace.list.findIndex(
+        (workspace) => workspace === desktopStore.state.workspace.active,
+      )
     })
 
     return {
-        active,
-        overview,
-        list,
-        workspaceActiveIndex,
-        setupWorkspaces,
-        setOverview,
-        setWorkspace,
+      active,
+      overview,
+      list,
+      workspaceActiveIndex,
+      setupWorkspaces,
+      setOverview,
+      setWorkspace,
     }
-})
+  },
+)

package/runtime/utils/utilApp.ts

@@ -1,32 +1,37 @@
-import type {Nuxt} from "@nuxt/schema";
+import type { Nuxt } from '@nuxt/schema'
 
-export function normalizeApplicationConfig(config: ApplicationConfig): ApplicationConfig {
-    const normalizedEntries: Record<string, ApplicationEntry> = {}
+export function normalizeApplicationConfig(
+  config: ApplicationConfig,
+): ApplicationConfig {
+  const normalizedEntries: Record<string, ApplicationEntry> = {}
 
+  if (config.entries) {
     for (const [key, entry] of Object.entries(config.entries)) {
-        normalizedEntries[key] = {
-            ...entry,
-            title: entry.title ?? config.title,
-            icon: entry.icon ?? config.icon,
-            category: entry.category ?? config.category,
-            visibility: entry.visibility ?? 'primary',
-        }
+      normalizedEntries[key] = {
+        ...entry,
+        title: entry.title ?? config.title,
+        icon: entry.icon ?? config.icon,
+        category: entry.category ?? config.category,
+        visibility: entry.visibility ?? 'primary',
+      }
     }
+  }
 
-    return {
-        ...config,
-        version: config.version ?? 'unknown',
-        description: config.description ?? '',
-        category: config.category ?? 'other',
-        entries: normalizedEntries,
-    }
+  return {
+    ...config,
+    version: config.version ?? 'unknown',
+    description: config.description ?? '',
+    category: config.category ?? 'other',
+    entries: normalizedEntries,
+  }
 }
 
 export function registerTailwindPath(nuxt: Nuxt, path: string) {
-    nuxt.options.runtimeConfig.app.owd = nuxt.options.runtimeConfig.app.owd || {}
-    nuxt.options.runtimeConfig.app.owd.tailwindPaths = nuxt.options.runtimeConfig.app.owd.tailwindPaths || []
+  nuxt.options.runtimeConfig.app.owd = nuxt.options.runtimeConfig.app.owd || {}
+  nuxt.options.runtimeConfig.app.owd.tailwindPaths =
+    nuxt.options.runtimeConfig.app.owd.tailwindPaths || []
 
-    if (!nuxt.options.runtimeConfig.app.owd.tailwindPaths.includes(path)) {
-        nuxt.options.runtimeConfig.app.owd.tailwindPaths.push(path)
-    }
+  if (!nuxt.options.runtimeConfig.app.owd.tailwindPaths.includes(path)) {
+    nuxt.options.runtimeConfig.app.owd.tailwindPaths.push(path)
+  }
 }