@owdproject/core 3.4.0 → 4.0.0-alpha.4

package/runtime/composables/useApplicationManager.ts

@@ -1,285 +0,0 @@
-import { reactive, markRaw, computed } from 'vue'
-import { ApplicationController } from '../internal/controllers/ApplicationController'
-import { normalizeApplicationConfig } from '../utils/utilApp'
-import { debugLog } from '../utils/utilDebug'
-import * as shellwords from 'shellwords'
-import getopts from "getopts"
-
-const apps = reactive(new Map<string, IApplicationController>())
-
-/**
- * Application Manager Composable (Singleton)
- */
-export function useApplicationManager() {
-  /**
-   * Define new application
-   *
-   * @param id
-   * @param config
-   */
-  async function defineApp(id: string, config: ApplicationConfig) {
-    if (isAppDefined(id)) {
-      debugLog(`App "${id}" is already defined`)
-      return getAppById(id)!
-    }
-
-    const normalizedConfig = normalizeApplicationConfig(config)
-    const applicationConfig = markRaw(normalizedConfig)
-
-    const applicationController: IApplicationController = new ApplicationController(id, applicationConfig)
-    await applicationController.initApplication()
-
-    apps.set(id, markRaw(applicationController))
-
-    return applicationController
-  }
-
-  /**
-   * Check if app has been defined
-   *
-   * @param {string} id
-   */
-  function isAppDefined(id: string) {
-    return getAppById(id)
-  }
-
-  /**
-   * Retrieves an app instance by its unique identifier
-   *
-   * @param {string} id
-   */
-  function getAppById(id: string) {
-    return apps.get(id)
-  }
-
-  /**
-   * Check if app is running
-   *
-   * @param {string} id
-   */
-  function isAppRunning(id: string) {
-    if (!isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController = getAppById(id)!
-    return applicationController.isRunning
-  }
-
-  /**
-   * Launch app entry
-   *
-   * @param id
-   * @param entryKey
-   * @param argument
-   */
-  async function launchAppEntry(
-    id: string,
-    entryKey: string,
-    argument: string = ''
-  ): Promise<IApplicationController | undefined | void> {
-    if (!isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController = getAppById(id)!
-
-    if (
-      applicationController.config.entries &&
-      !applicationController.config.entries.hasOwnProperty(entryKey)
-    ) {
-      throw Error(`App entry "${entryKey}" is not defined in ${id} application`)
-    }
-
-    const entry: ApplicationEntry = applicationController.config.entries[entryKey]!
-
-    if (argument) argument = ` ${argument}`
-
-    await execAppCommand(applicationController.id, entry.command + argument)
-  }
-
-  /**
-   * Run app command
-   *
-   * @param id
-   * @param rawCommand
-   */
-  async function execAppCommand(
-    id: string,
-    rawCommand: string,
-  ): Promise<CommandOutput> {
-    if (!isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController = getAppById(id)!
-
-    const args = shellwords.split(rawCommand)
-    const parsed = getopts(args)
-    const command: string = parsed._[0]
-
-    if (
-      applicationController.config.commands &&
-      !applicationController.config.commands.hasOwnProperty(command)
-    ) {
-      throw Error(
-        `App command "${command}" is not defined in ${id} application`,
-      )
-    }
-
-    const commandFn: any = applicationController.config.commands![command]
-
-    const commandOutput = await commandFn(applicationController, parsed)
-
-    applicationController.setRunning(true)
-
-    return commandOutput
-  }
-
-  /**
-   * Close application
-   *
-   * @param id
-   */
-  function closeApp(id: string) {
-    if (!isAppDefined(id)) {
-      throw Error(`App "${id}" is not defined`)
-    }
-
-    const applicationController = getAppById(id)!
-
-    applicationController.closeAllWindows()
-    applicationController.setRunning(false)
-  }
-
-  /**
-   * Array of available menu entries for system bars, docks
-   */
-  const appsEntries = computed(() => {
-    const entries: ApplicationEntryWithInherited[] = []
-
-    for (const applicationController of apps.values()) {
-      if (!applicationController.config.entries) {
-        continue
-      }
-
-      for (const entryKey of Object.keys(applicationController.config.entries)) {
-        const entry = applicationController.config.entries[entryKey]!
-
-        entries.push({
-          application: applicationController,
-          title: entry.title ?? applicationController.config.title,
-          icon: entry.icon ?? applicationController.config.icon,
-          category: entry.category ?? applicationController.config.category,
-          visibility: entry.visibility ?? 'primary',
-          command: entry.command,
-        })
-      }
-    }
-
-    return entries
-  })
-
-  /**
-   * Array of opened windows for system bars, docks
-   */
-  const windowsOpened = computed(() => {
-    const windows = new Map<string, IWindowController>()
-
-    for (const applicationController of apps.values()) {
-      if (
-        !applicationController.isRunning &&
-        applicationController.openWindowCount.value === 0
-      ) {
-        continue
-      }
-
-      for (const [windowId, window] of applicationController.windows) {
-        windows.set(windowId, window)
-      }
-    }
-
-    return windows
-  })
-
-  /**
-   * Array of running applications
-   */
-  const appsRunning = computed(() => {
-    const runningApps: IApplicationController[] = []
-
-    for (const applicationController of apps.values()) {
-      const openCount = applicationController.openWindowCount.value
-      if (applicationController.isRunning || openCount > 0) {
-        runningApps.push(applicationController)
-      }
-    }
-
-    return runningApps
-  })
-
-  function getWindowOpenedId(windowId: string) {
-    for (const window of windowsOpened.value.values()) {
-      if (window.state.id === windowId) {
-        return window
-      }
-    }
-  }
-
-  /**
-   * Gets all unique categories from the installed apps
-   */
-  const appCategories = computed(() => {
-    const categories = new Set<string>()
-
-    for (const applicationController of apps.values()) {
-      if (applicationController.config.category) {
-        categories.add(applicationController.config.category)
-      }
-    }
-
-    return Array.from(categories).sort()
-  })
-
-  /**
-   * Gets the apps ordered by category
-   */
-  const appsByCategory = computed(() => {
-    const categorizedApps: {
-      [category: string]: IApplicationController[]
-    } = {}
-
-    for (const applicationController of 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
-  })
-
-  return {
-    defineApp,
-    isAppDefined,
-    getAppById,
-    isAppRunning,
-    launchAppEntry,
-    execAppCommand,
-    closeApp,
-    getWindowOpenedId,
-    apps,
-    appsEntries,
-    appsRunning,
-    windowsOpened,
-    appCategories,
-    appsByCategory,
-  }
-}

package/runtime/composables/useBlockNonInputContextMenu.ts

@@ -1,30 +0,0 @@
-import { useEventListener } from '@vueuse/core'
-import { isDebugMode } from '../utils/utilDebug'
-
-/**
- * Blocks the browser context menu on non-input elements (typical desktop shell behaviour).
- * Debug builds skip blocking so DevTools stay usable when {@link isDebugMode} is true.
- */
-export function useBlockNonInputContextMenu() {
-  useEventListener(
-    document,
-    'contextmenu',
-    (event: MouseEvent) => {
-      if (isDebugMode()) return
-
-      const target = event.target as HTMLElement | null
-      if (!target) return
-
-      const tag = target.tagName?.toLowerCase()
-      const isInput =
-        tag === 'input' ||
-        tag === 'textarea' ||
-        Boolean(target.isContentEditable)
-
-      if (!isInput) {
-        event.preventDefault()
-      }
-    },
-    { passive: false },
-  )
-}

package/runtime/composables/useDesktopConfig.ts

@@ -1,8 +0,0 @@
-import { useRuntimeConfig } from 'nuxt/app'
-import { computed } from 'vue'
-
-/** Reactive view of `runtimeConfig.public.desktop` (full desktop.config merge + coreVersion). */
-export function useDesktopConfig() {
-  const runtimeConfig = useRuntimeConfig()
-  return computed(() => runtimeConfig.public.desktop)
-}

package/runtime/composables/useDesktopDialogs.ts

@@ -1,16 +0,0 @@
-import { inject } from 'vue'
-import { DESKTOP_DIALOG_PROVIDER_KEY } from '../constants/desktopShellKeys'
-import {
-  createBrowserFallbackDialogProvider,
-  type DesktopDialogProvider,
-} from '../dialogs/desktopDialogProvider'
-
-/**
- * Returns the active desktop dialog provider (theme) or a browser fallback.
- */
-export function useDesktopDialogs(): DesktopDialogProvider {
-  return (
-    inject(DESKTOP_DIALOG_PROVIDER_KEY, null) ??
-    createBrowserFallbackDialogProvider()
-  )
-}

package/runtime/composables/useDesktopExtension.ts

@@ -1,8 +0,0 @@
-import { computed } from 'vue'
-import { useDesktopConfig } from './useDesktopConfig'
-
-/** Readonly slice for an extension namespace (`fs`, `terminal`, or custom `configKey`). */
-export function useDesktopExtension<K extends string>(key: K) {
-  const desktop = useDesktopConfig()
-  return computed(() => desktop.value?.[key as keyof typeof desktop.value])
-}

package/runtime/composables/useDesktopManager.ts

@@ -1,51 +0,0 @@
-import { computed } from 'vue'
-import { useAppConfig } from 'nuxt/app'
-import { defu } from 'defu'
-import { useDesktopStore } from '../stores/storeDesktop'
-import { useDesktopDefaultAppsStore } from '../stores/storeDesktopDefaultApps'
-
-/**
- * Desktop Manager composable (singleton pattern via Pinia + app config).
- * Agnostic of any theme: merges runtime shell config and exposes default-app routing.
- */
-export function useDesktopManager() {
-  const appConfig = useAppConfig()
-  const desktopStore = useDesktopStore()
-  const defaultAppsStore = useDesktopDefaultAppsStore()
-
-  /**
-   * Merges and sets the desktop config at runtime (shell geometry, feature flags, etc.).
-   */
-  function setConfig(newConfig: DesktopConfig) {
-    if (!appConfig) return
-
-    appConfig.desktop = defu(
-      newConfig,
-      (appConfig.desktop ?? {}) as DesktopConfig,
-    ) as DesktopConfig
-  }
-
-  /** Map of feature name → default app handler (e.g. terminal, browser). */
-  const defaultApps = computed(
-    () => desktopStore.state.defaultApps,
-  )
-
-  function getDefaultApp(feature: string) {
-    return defaultAppsStore.getDefaultApp(feature)
-  }
-
-  function setDefaultApp(
-    feature: string,
-    application: IApplicationController,
-    entry: string,
-  ) {
-    defaultAppsStore.setDefaultApp(feature, application, entry)
-  }
-
-  return {
-    setConfig,
-    defaultApps,
-    getDefaultApp,
-    setDefaultApp,
-  }
-}

package/runtime/composables/useDesktopManifest.ts

@@ -1,17 +0,0 @@
-import { computed } from 'vue'
-import { useDesktopConfig } from './useDesktopConfig'
-
-export function hasDesktopModule(pkg: string) {
-  const desktop = useDesktopConfig()
-  return computed(() => desktop.value?.modules?.includes(pkg) ?? false)
-}
-
-export function hasDesktopApp(pkg: string) {
-  const desktop = useDesktopConfig()
-  return computed(() => desktop.value?.apps?.includes(pkg) ?? false)
-}
-
-export function hasDesktopExtension(key: string) {
-  const desktop = useDesktopConfig()
-  return computed(() => Boolean(desktop.value?.[key as keyof typeof desktop.value]))
-}

package/runtime/composables/useDesktopSession.ts

@@ -1,27 +0,0 @@
-import { useRouter } from 'nuxt/app'
-import { ref } from 'vue'
-
-/**
- * Neutral API for “leave the desktop shell” flows (shutdown animation → start route).
- * Themes keep their own `/start` / `/boot` pages and styling.
- */
-const shuttingDown = ref(false)
-
-export function useDesktopSession() {
-  const initiateShutdownToStart = () => {
-    shuttingDown.value = true
-
-    setTimeout(() => {
-      useRouter()
-        .push('/start')
-        .then(() => {
-          shuttingDown.value = false
-        })
-    }, 2000)
-  }
-
-  return {
-    shuttingDown,
-    initiateShutdownToStart,
-  }
-}

package/runtime/composables/useDesktopShellIdentity.ts

@@ -1,99 +0,0 @@
-import { computed, ref } from 'vue'
-import { useRuntimeConfig } from 'nuxt/app'
-
-export type ShellIdentity = {
-  userId: string
-  displayName: string
-  avatarUrl: string | null
-  userHome: string
-}
-
-const GUEST_USER_ID = 'guest'
-
-const identity = ref<ShellIdentity | null>(null)
-
-export function sanitizeUserHomeSegment(input: string): string {
-  const cleaned = input
-    .trim()
-    .replace(/^@/, '')
-    .replace(/[^\w.\-]/g, '_')
-    .slice(0, 64)
-  return cleaned || 'user'
-}
-
-/** Build a VFS home path from an auth handle (e.g. Bluesky `@alice.bsky.social`). */
-export function userHomeFromHandle(handle: string, base = '/home'): string {
-  const baseNorm = base.endsWith('/') ? base.slice(0, -1) : base
-  return `${baseNorm}/${sanitizeUserHomeSegment(handle)}`
-}
-
-function resolveDefaultHome(): string {
-  try {
-    const config = useRuntimeConfig()
-    const desktop = config.public.desktop as {
-      fs?: { defaultUserHome?: string }
-    }
-    const home = desktop.fs?.defaultUserHome?.trim()
-    if (home) return home.startsWith('/') ? home : `/${home}`
-  } catch {
-    /* outside Nuxt setup */
-  }
-  return '/home/Guest'
-}
-
-function guestIdentity(defaultHome: string): ShellIdentity {
-  return {
-    userId: GUEST_USER_ID,
-    displayName: 'Guest',
-    avatarUrl: null,
-    userHome: defaultHome,
-  }
-}
-
-/**
- * Shell session identity (display + VFS home). Auth modules call {@link setShellIdentity}
- * after login; defaults to Guest.
- */
-export function useDesktopShellIdentity() {
-  function ensureIdentity(): ShellIdentity {
-    if (!identity.value) {
-      identity.value = guestIdentity(resolveDefaultHome())
-    }
-    return identity.value
-  }
-
-  const userId = computed(() => ensureIdentity().userId)
-  const displayName = computed(() => ensureIdentity().displayName)
-  const avatarUrl = computed(() => ensureIdentity().avatarUrl)
-  const userHome = computed(() => ensureIdentity().userHome)
-  const isGuest = computed(() => userId.value === GUEST_USER_ID)
-
-  function setShellIdentity(partial: Partial<ShellIdentity>) {
-    const current = ensureIdentity()
-    identity.value = {
-      ...current,
-      ...partial,
-      userId: partial.userId?.trim() || current.userId,
-      displayName: partial.displayName?.trim() || current.displayName,
-      userHome: partial.userHome?.trim()
-        ? partial.userHome.startsWith('/')
-          ? partial.userHome
-          : `/${partial.userHome}`
-        : current.userHome,
-    }
-  }
-
-  function clearShellIdentity() {
-    identity.value = guestIdentity(resolveDefaultHome())
-  }
-
-  return {
-    userId,
-    displayName,
-    avatarUrl,
-    userHome,
-    isGuest,
-    setShellIdentity,
-    clearShellIdentity,
-  }
-}

package/runtime/composables/useDesktopShellOptions.ts

@@ -1,36 +0,0 @@
-import { useAppConfig } from 'nuxt/app'
-import { computed } from 'vue'
-
-/**
- * Reads shared desktop shell flags from `appConfig.desktop` (merged from runtime config).
- * Themes use this for taskbar/dock visibility without duplicating `useAppConfig` wiring.
- */
-type DesktopAppShape = {
-  systemBar?: {
-    enabled?: boolean
-    position?: string
-    startButton?: boolean
-  }
-}
-
-export function useDesktopShellOptions() {
-  const appConfig = useAppConfig()
-
-  const desktop = () => appConfig.desktop as DesktopAppShape | undefined
-
-  const systemBarEnabled = computed(
-    () => desktop()?.systemBar?.enabled !== false,
-  )
-
-  const systemBarPosition = computed(() => desktop()?.systemBar?.position)
-
-  const startButtonEnabled = computed(
-    () => desktop()?.systemBar?.startButton !== false,
-  )
-
-  return {
-    systemBarEnabled,
-    systemBarPosition,
-    startButtonEnabled,
-  }
-}

package/runtime/composables/useDesktopShellReady.ts

@@ -1,7 +0,0 @@
-import { useNuxtApp } from 'nuxt/app'
-
-/** True after `desktop-shell-init` has bound Pinia and run kernel workspace bootstrap. */
-export function useDesktopShellReady() {
-  const nuxtApp = useNuxtApp()
-  return nuxtApp.$desktopShellReady === true
-}

package/runtime/composables/useDesktopWorkArea.ts

@@ -1,93 +0,0 @@
-import type { Ref } from 'vue'
-import { onScopeDispose, watch } from 'vue'
-import {
-  EMPTY_DESKTOP_WORK_AREA,
-  useDesktopWindowStore,
-} from '@owdproject/core/runtime/stores/storeDesktopWindow'
-import { useDesktopWorkspaceStore } from '@owdproject/core/runtime/stores/storeDesktopWorkspace'
-
-function measureElement(el: HTMLElement) {
-  const rect = el.getBoundingClientRect()
-  return {
-    x: rect.left,
-    y: rect.top,
-    width: rect.width,
-    height: rect.height,
-  }
-}
-
-/**
- * Tracks the desktop shell stage rectangle (area under system bar, above dock).
- * Writes measured bounds to {@link useDesktopWindowStore.workArea}.
- * Pass the same ref themes use for workspace overview live scale.
- */
-export function useDesktopWorkArea(
-  shellStageRef: Ref<HTMLElement | null | undefined>,
-) {
-  const desktopWindowStore = useDesktopWindowStore()
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-  let resizeObserver: ResizeObserver | null = null
-
-  function refreshWorkArea() {
-    const el = shellStageRef.value
-    if (!el) {
-      desktopWindowStore.setWorkArea({ ...EMPTY_DESKTOP_WORK_AREA })
-      return
-    }
-    desktopWindowStore.setWorkArea(measureElement(el))
-  }
-
-  function disconnectObserver() {
-    resizeObserver?.disconnect()
-    resizeObserver = null
-  }
-
-  function observeStage(el: HTMLElement) {
-    disconnectObserver()
-    refreshWorkArea()
-
-    if (typeof ResizeObserver === 'undefined') {
-      return
-    }
-
-    resizeObserver = new ResizeObserver(() => refreshWorkArea())
-    resizeObserver.observe(el)
-  }
-
-  watch(
-    shellStageRef,
-    (el) => {
-      disconnectObserver()
-      if (el instanceof HTMLElement) {
-        observeStage(el)
-      } else {
-        desktopWindowStore.setWorkArea({ ...EMPTY_DESKTOP_WORK_AREA })
-      }
-    },
-    { immediate: true },
-  )
-
-  watch(
-    () => desktopWorkspaceStore.overview,
-    (open) => {
-      if (!open) {
-        refreshWorkArea()
-      }
-    },
-  )
-
-  if (typeof globalThis !== 'undefined') {
-    globalThis.addEventListener('resize', refreshWorkArea)
-    onScopeDispose(() => {
-      globalThis.removeEventListener('resize', refreshWorkArea)
-      disconnectObserver()
-    })
-  } else {
-    onScopeDispose(disconnectObserver)
-  }
-
-  return {
-    refreshWorkArea,
-  }
-}