@owdproject/core 3.4.0 → 4.0.0-alpha.3

package/runtime/components/window/DesktopCoreWindowSnapHintsBase.vue

@@ -1,74 +0,0 @@
-<script setup lang="ts">
-import { computed } from 'vue'
-import { useDesktopWorkspaceStore } from '@owdproject/core/runtime/stores/storeDesktopWorkspace'
-import { useWindowSnapDrop } from '@owdproject/core/runtime/composables/useWindowSnapDrop'
-
-const props = defineProps<{
-  enabled?: boolean
-}>()
-
-const desktopWorkspaceStore = useDesktopWorkspaceStore()
-const { snapHint, snapHintRect, isSnapDragActive } = useWindowSnapDrop()
-
-const visible = computed(
-  () =>
-    props.enabled !== false &&
-    !desktopWorkspaceStore.overview &&
-    isSnapDragActive.value &&
-    snapHint.value !== null &&
-    snapHintRect.value !== null,
-)
-
-const hintStyle = computed(() => {
-  const rect = snapHintRect.value
-  if (!rect) return undefined
-
-  return {
-    left: `${rect.x}px`,
-    top: `${rect.y}px`,
-    width: `${rect.width}px`,
-    height: `${rect.height}px`,
-  }
-})
-</script>
-
-<template>
-  <div
-    v-if="visible"
-    class="owd-window-snap-hints"
-    aria-hidden="true"
-  >
-    <div
-      class="owd-window-snap-hints__zone"
-      :class="`owd-window-snap-hints__zone--${snapHint}`"
-      :style="hintStyle"
-    >
-      <slot
-        :zone="snapHint"
-        :rect="snapHintRect"
-      />
-    </div>
-  </div>
-</template>
-
-<style scoped>
-.owd-window-snap-hints {
-  position: fixed;
-  inset: 0;
-  pointer-events: none;
-  z-index: 999998;
-}
-
-.owd-window-snap-hints__zone {
-  position: fixed;
-  box-sizing: border-box;
-  border: 2px solid rgba(96, 165, 250, 0.85);
-  background: rgba(96, 165, 250, 0.18);
-  border-radius: 4px;
-  transition:
-    left 80ms ease,
-    top 80ms ease,
-    width 80ms ease,
-    height 80ms ease;
-}
-</style>

package/runtime/components/workspace/DesktopCoreWorkspaceEdgeHintsBase.vue

@@ -1,84 +0,0 @@
-<script setup lang="ts">
-import { computed } from 'vue'
-import { useWorkspaceEdgeDrop } from '@owdproject/core/runtime/composables/useWorkspaceEdgeDrop'
-import { useDesktopWorkspaceStore } from '@owdproject/core/runtime/stores/storeDesktopWorkspace'
-
-const props = defineProps<{
-  enabled?: boolean
-}>()
-
-const desktopWorkspaceStore = useDesktopWorkspaceStore()
-const { edgeHint, edgeTargetDesktopIndex } = useWorkspaceEdgeDrop()
-
-const visible = computed(
-  () =>
-    props.enabled !== false &&
-    !desktopWorkspaceStore.overview &&
-    desktopWorkspaceStore.list.length > 1 &&
-    edgeHint.value !== null &&
-    edgeTargetDesktopIndex.value !== null,
-)
-</script>
-
-<template>
-  <div
-    v-if="visible"
-    class="owd-workspace-edge-hints"
-    aria-hidden="true"
-  >
-    <div
-      class="owd-workspace-edge-hints__zone owd-workspace-edge-hints__zone--left"
-      :class="{
-        'owd-workspace-edge-hints__zone--active': edgeHint === 'left',
-      }"
-    >
-      <slot
-        name="left"
-        :desktop-index="edgeTargetDesktopIndex"
-        :side="'left' as const"
-      />
-    </div>
-    <div
-      class="owd-workspace-edge-hints__zone owd-workspace-edge-hints__zone--right"
-      :class="{
-        'owd-workspace-edge-hints__zone--active': edgeHint === 'right',
-      }"
-    >
-      <slot
-        name="right"
-        :desktop-index="edgeTargetDesktopIndex"
-        :side="'right' as const"
-      />
-    </div>
-  </div>
-</template>
-
-<style scoped>
-.owd-workspace-edge-hints {
-  position: fixed;
-  inset: 0;
-  pointer-events: none;
-  z-index: 999998;
-}
-
-.owd-workspace-edge-hints__zone {
-  position: fixed;
-  top: 0;
-  bottom: 0;
-  width: 72px;
-  opacity: 0;
-  transition: opacity 120ms ease;
-}
-
-.owd-workspace-edge-hints__zone--left {
-  left: 0;
-}
-
-.owd-workspace-edge-hints__zone--right {
-  right: 0;
-}
-
-.owd-workspace-edge-hints__zone--active {
-  opacity: 1;
-}
-</style>

package/runtime/composables/useApplicationEntries.ts

@@ -1,51 +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 useApplicationEntries() {
-  const applicationManager = useApplicationManager()
-
-  const sortedAppEntries = function (
-    sortBy: SortBy = 'title',
-    visibility: Visibility = 'primary',
-  ): Ref<ApplicationEntryWithInherited[]> {
-    return computed(() => {
-      const currentEntries = [...applicationManager.appsEntries.value]
-
-      // 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 }
-}

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,
-  }
-}