@owdproject/core 3.4.0 → 4.0.0-alpha.4

package/runtime/composables/useTerminalManager.ts

@@ -1,159 +0,0 @@
-import { useApplicationManager } from './useApplicationManager'
-import { debugLog } from '../utils/utilDebug'
-
-const commands = new Map<string, TerminalCommand>()
-
-// ─── formatting helpers ──────────────────────────────────────────────────────
-
-function padEnd(str: string, len: number): string {
-  return str.length >= len ? str : str + ' '.repeat(len - str.length)
-}
-
-function buildHelpList(): string {
-  const sorted = Array.from(commands.values()).sort((a, b) =>
-    a.name.localeCompare(b.name),
-  )
-
-  const colWidth = Math.max(...sorted.map((c) => c.name.length)) + 4
-
-  const rows = sorted
-    .map((cmd) => `  ${padEnd(cmd.name, colWidth)}${cmd.description ?? ''}`)
-    .join('\n')
-
-  return (
-    `Available commands:\n\n` +
-    rows +
-    `\n\nType 'help <command>' for more details.`
-  )
-}
-
-function buildHelpDetail(cmd: TerminalCommand): string {
-  const lines: string[] = []
-
-  lines.push(`  ${cmd.name}${cmd.description ? ` — ${cmd.description}` : ''}`)
-  lines.push('')
-
-  if (cmd.usage) {
-    lines.push(`  Usage: ${cmd.usage}`)
-    lines.push('')
-  }
-
-  if (cmd.args && cmd.args.length > 0) {
-    lines.push('  Arguments:')
-    const argColW = Math.max(...cmd.args.map((a) => a.name.length)) + 4
-    for (const arg of cmd.args) {
-      const required = arg.required ? '' : ' (optional)'
-      lines.push(
-        `    ${padEnd(arg.name, argColW)}${arg.description ?? ''}${required}`,
-      )
-    }
-    lines.push('')
-  }
-
-  if (cmd.options && cmd.options.length > 0) {
-    lines.push('  Options:')
-    const optColW = Math.max(...cmd.options.map((o) => o.flag.length)) + 4
-    for (const opt of cmd.options) {
-      lines.push(`    ${padEnd(opt.flag, optColW)}${opt.description ?? ''}`)
-    }
-    lines.push('')
-  }
-
-  return lines.join('\n').trimEnd()
-}
-
-// ─── composable ─────────────────────────────────────────────────────────────
-
-/**
- * Terminal Manager Composable (Singleton)
- */
-export function useTerminalManager(): ITerminalManager {
-  /**
-   * Add a new terminal command
-   */
-  const addCommand = (command: TerminalCommand) => {
-    for (const existingCommand of commands.keys()) {
-      if (
-        existingCommand.startsWith(command.name) ||
-        command.name.startsWith(existingCommand)
-      ) {
-        throw new Error(`Command prefix conflict with "${existingCommand}"`)
-      }
-    }
-
-    commands.set(command.name, command)
-    debugLog(`Registered terminal command: ${command.name} → ${command.applicationId}`)
-  }
-
-  /**
-   * List all registered command names
-   */
-  const listCommands = (): string[] => {
-    return Array.from(commands.keys())
-  }
-
-  /**
-   * Get a single command by name
-   */
-  const getCommand = (name: string): TerminalCommand | undefined => {
-    return commands.get(name)
-  }
-
-  /**
-   * Get all registered commands with metadata
-   */
-  const getAllCommands = (): TerminalCommand[] => {
-    return Array.from(commands.values())
-  }
-
-  /**
-   * Execute a terminal command
-   */
-  const execCommand = async (input: string): Promise<CommandOutput | void> => {
-    const applicationManager = useApplicationManager()
-
-    const trimmed = input.trim()
-    const [name, ...rest] = trimmed.split(/\s+/)
-
-    if (!name) return
-
-    // ── built-in: help ────────────────────────────────────────────────────────
-    if (name === 'help') {
-      const target = rest[0]
-
-      if (!target) {
-        return { message: buildHelpList() }
-      }
-
-      const cmd = commands.get(target)
-      if (!cmd) {
-        return {
-          message: `help: command not found: '${target}'\nType 'help' to list available commands.`,
-          isError: true,
-        }
-      }
-
-      return { message: buildHelpDetail(cmd) }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-
-    if (!commands.has(name)) {
-      return {
-        message: `Command not found: '${name}'\nType 'help' to list available commands.`,
-        isError: true,
-      }
-    }
-
-    const application = commands.get(name)!
-
-    return applicationManager.execAppCommand(application.applicationId, input)
-  }
-
-  return {
-    addCommand,
-    listCommands,
-    getCommand,
-    getAllCommands,
-    execCommand,
-  }
-}

package/runtime/composables/useToggleWindowMaximize.ts

@@ -1,35 +0,0 @@
-import { inject } from 'vue'
-import {
-  useDesktopWindowStore,
-} from '../stores/storeDesktopWindow'
-import { toggleWindowMaximizeLayout } from '../utils/utilWindowMaximizeLayout'
-import {
-  DESKTOP_TOGGLE_WINDOW_MAXIMIZE_KEY,
-  type DesktopToggleWindowMaximizeFn,
-} from '../constants/desktopShellKeys'
-
-export type { DesktopToggleWindowMaximizeFn }
-
-/**
- * Maximize / restore a window. Themes may override via
- * {@link DESKTOP_TOGGLE_WINDOW_MAXIMIZE_KEY}; otherwise uses
- * {@link useDesktopWindowStore.workArea} (when measured) or
- * {@link IWindowController.actions.toggleMaximize}.
- */
-export function useToggleWindowMaximize(): DesktopToggleWindowMaximizeFn {
-  const override = inject(DESKTOP_TOGGLE_WINDOW_MAXIMIZE_KEY, null)
-  if (override) return override
-
-  const desktopWindowStore = useDesktopWindowStore()
-
-  return function toggle(win: IWindowController | undefined) {
-    if (!win?.instanced) return false
-
-    const workArea = desktopWindowStore.workArea
-    if (workArea.width > 0 && workArea.height > 0) {
-      return toggleWindowMaximizeLayout(win, workArea)
-    }
-
-    return win.actions.toggleMaximize()
-  }
-}

package/runtime/composables/useWindowDragHandlers.ts

@@ -1,47 +0,0 @@
-import type { IWindowController } from '@owdproject/core'
-import { useDesktopWindowStore } from '../stores/storeDesktopWindow'
-import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace'
-import { useWorkspaceEdgeDrop } from './useWorkspaceEdgeDrop'
-import { useWindowSnapDrop } from './useWindowSnapDrop'
-
-/**
- * Wire workspace edge drop and window snap to theme `Window.vue` drag events.
- */
-export function useWindowDragHandlers(
-  getWindow: () => IWindowController | undefined,
-) {
-  const desktopWindowStore = useDesktopWindowStore()
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-  const { beginWindowDrag, endWindowDrag } = useWorkspaceEdgeDrop()
-  const { beginWindowSnapDrag, endWindowSnapDrag } = useWindowSnapDrop()
-
-  function onDragStart() {
-    const win = getWindow()
-    if (!win?.state?.id || desktopWorkspaceStore.overview) return
-
-    beginWindowDrag(win.state.id)
-    beginWindowSnapDrag(
-      win.state.id,
-      desktopWindowStore.workArea,
-      win.isMaximizable,
-    )
-  }
-
-  function onDragEnd(data: { left: number; top: number }) {
-    const win = getWindow()
-    if (!win || desktopWorkspaceStore.overview) return
-
-    const snapped = endWindowSnapDrag(win)
-    if (snapped) return
-
-    const moved = endWindowDrag(win)
-    if (!moved) {
-      win.actions.setPosition({ x: data.left, y: data.top })
-      if (win.state.layout && win.state.layout !== 'normal') {
-        win.actions.clearLayout()
-      }
-    }
-  }
-
-  return { onDragStart, onDragEnd }
-}

package/runtime/composables/useWindowSnapDrop.ts

@@ -1,112 +0,0 @@
-import type { DesktopWorkAreaRect, IWindowController } from '@owdproject/core'
-import type { Ref } from 'vue'
-import { computed, ref } from 'vue'
-import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace'
-import {
-  detectSnapZone,
-  type SnapZoneHint,
-} from '../utils/utilDetectSnapZone'
-import { applySnapToWindow, computeSnapRect } from '../utils/utilWindowLayout'
-import { useWorkspaceEdgeDrop } from './useWorkspaceEdgeDrop'
-
-const snapHint = ref<SnapZoneHint | null>(null)
-const isSnapDragActive = ref(false)
-let snapDraggingWindowId: string | null = null
-let activeWorkArea: DesktopWorkAreaRect = { x: 0, y: 0, width: 0, height: 0 }
-
-function onDocumentPointerMove(e: PointerEvent) {
-  updateSnapHintFromPointer(e.clientX, e.clientY)
-}
-
-function onDocumentMouseMove(e: MouseEvent) {
-  updateSnapHintFromPointer(e.clientX, e.clientY)
-}
-
-function stopSnapPointerTracking() {
-  document.removeEventListener('pointermove', onDocumentPointerMove)
-  document.removeEventListener('mousemove', onDocumentMouseMove)
-}
-
-function updateSnapHintFromPointer(clientX: number, clientY: number) {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-  if (!isSnapDragActive.value || desktopWorkspaceStore.overview) {
-    snapHint.value = null
-    return
-  }
-
-  const deferSide =
-    desktopWorkspaceStore.list.length > 1 &&
-    !desktopWorkspaceStore.overview
-
-  snapHint.value = detectSnapZone(clientX, clientY, activeWorkArea, {
-    deferSideSnapForWorkspaceEdge: deferSide,
-  })
-}
-
-/**
- * While dragging a maximizable window, highlight snap zones in the shell work area.
- */
-export function useWindowSnapDrop() {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-  function beginWindowSnapDrag(
-    windowId: string,
-    workArea: DesktopWorkAreaRect,
-    maximizable: boolean,
-  ) {
-    if (desktopWorkspaceStore.overview) return
-    if (!maximizable) return
-    if (workArea.width <= 0 || workArea.height <= 0) return
-
-    snapDraggingWindowId = windowId
-    isSnapDragActive.value = true
-    activeWorkArea = { ...workArea }
-    snapHint.value = null
-
-    document.addEventListener('pointermove', onDocumentPointerMove, {
-      passive: true,
-    })
-    document.addEventListener('mousemove', onDocumentMouseMove, {
-      passive: true,
-    })
-  }
-
-  function commitSnapDrop(win: IWindowController): boolean {
-    const zone = snapHint.value
-    if (!zone || !snapDraggingWindowId) return false
-
-    return applySnapToWindow(win, zone, activeWorkArea)
-  }
-
-  function endWindowSnapDrag(win?: IWindowController): boolean {
-    stopSnapPointerTracking()
-
-    let snapped = false
-    if (win && snapHint.value) {
-      snapped = commitSnapDrop(win)
-    }
-
-    isSnapDragActive.value = false
-    snapDraggingWindowId = null
-    snapHint.value = null
-
-    return snapped
-  }
-
-  const snapHintRect = computed(() => {
-    const zone = snapHint.value
-    if (!zone || activeWorkArea.width <= 0) return null
-
-    return computeSnapRect(zone, activeWorkArea)
-  })
-
-  return {
-    snapHint,
-    snapHintRect,
-    isSnapDragActive,
-    beginWindowSnapDrag,
-    endWindowSnapDrag,
-    activeWorkArea: () => activeWorkArea,
-  }
-}

package/runtime/composables/useWorkspaceEdgeDrop.ts

@@ -1,176 +0,0 @@
-import type { IWindowController } from '@owdproject/core'
-import { computed, ref } from 'vue'
-import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace'
-import { WORKSPACE_EDGE_DROP_PX } from '../constants/shellLayout'
-
-const edgeHint = ref<'left' | 'right' | null>(null)
-const isWindowDragActive = ref(false)
-let draggingWindowId: string | null = null
-
-function adjacentWorkspaceId(side: 'left' | 'right'): string | null {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-  if (desktopWorkspaceStore.overview) return null
-  const list = desktopWorkspaceStore.list
-  if (list.length < 2) return null
-
-  const index = desktopWorkspaceStore.workspaceActiveIndex
-  if (index < 0) return null
-
-  if (side === 'left' && index > 0) {
-    return list[index - 1] ?? null
-  }
-  if (side === 'right' && index < list.length - 1) {
-    return list[index + 1] ?? null
-  }
-  return null
-}
-
-function updateEdgeHintFromClientX(clientX: number) {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-  if (!isWindowDragActive.value || desktopWorkspaceStore.overview) {
-    edgeHint.value = null
-    return
-  }
-
-  const viewportWidth =
-    typeof globalThis !== 'undefined' ? globalThis.innerWidth : 0
-
-  if (clientX <= WORKSPACE_EDGE_DROP_PX && adjacentWorkspaceId('left')) {
-    edgeHint.value = 'left'
-    return
-  }
-
-  if (
-    clientX >= viewportWidth - WORKSPACE_EDGE_DROP_PX &&
-    adjacentWorkspaceId('right')
-  ) {
-    edgeHint.value = 'right'
-    return
-  }
-
-  edgeHint.value = null
-}
-
-function onDocumentPointerMove(e: PointerEvent) {
-  updateEdgeHintFromClientX(e.clientX)
-}
-
-function stopPointerTracking() {
-  document.removeEventListener('pointermove', onDocumentPointerMove)
-}
-
-/**
- * While dragging a window (normal desktop, not overview), highlight left/right
- * screen edges when an adjacent workspace exists so the user can drop there.
- */
-export function useWorkspaceEdgeDrop() {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-  function beginWindowDrag(windowId: string) {
-    if (desktopWorkspaceStore.overview) return
-    if (desktopWorkspaceStore.list.length < 2) return
-
-    draggingWindowId = windowId
-    isWindowDragActive.value = true
-    edgeHint.value = null
-
-    document.addEventListener('pointermove', onDocumentPointerMove, {
-      passive: true,
-    })
-  }
-
-  function commitEdgeDrop(win: IWindowController) {
-    const side = edgeHint.value
-    if (!side || !draggingWindowId) return false
-
-    const targetWorkspaceId = adjacentWorkspaceId(side)
-    if (!targetWorkspaceId) return false
-
-    win.actions.setWorkspace(targetWorkspaceId)
-    desktopWorkspaceStore.setWorkspace(targetWorkspaceId)
-
-    const inset = WORKSPACE_EDGE_DROP_PX + 24
-    const pos = win.position
-    if (pos && typeof pos.y === 'number') {
-      const viewportWidth =
-        typeof globalThis !== 'undefined' ? globalThis.innerWidth : 1920
-      const rawWidth = win.size?.width ?? 400
-      const width =
-        typeof rawWidth === 'number'
-          ? rawWidth
-          : Number.parseFloat(String(rawWidth)) || 400
-      const x =
-        side === 'left'
-          ? inset
-          : Math.max(inset, viewportWidth - width - inset)
-      win.actions.setPosition({ x, y: pos.y })
-    }
-
-    return true
-  }
-
-  function endWindowDrag(win?: IWindowController): boolean {
-    stopPointerTracking()
-
-    let moved = false
-    if (win && edgeHint.value) {
-      moved = commitEdgeDrop(win)
-    }
-
-    isWindowDragActive.value = false
-    draggingWindowId = null
-    edgeHint.value = null
-
-    return moved
-  }
-
-  const edgeTargetDesktopIndex = computed(() => {
-    const side = edgeHint.value
-    if (!side) return null
-
-    const targetId = adjacentWorkspaceId(side)
-    if (!targetId) return null
-
-    const index = desktopWorkspaceStore.list.indexOf(targetId)
-    return index >= 0 ? index + 1 : null
-  })
-
-  return {
-    edgeHint,
-    edgeTargetDesktopIndex,
-    isWindowDragActive,
-    beginWindowDrag,
-    endWindowDrag,
-    adjacentWorkspaceId,
-  }
-}
-
-/**
- * Wire {@link useWorkspaceEdgeDrop} to DesktopWindow drag events (theme Window wrapper).
- */
-export function useWorkspaceEdgeDropWindowHandlers(
-  getWindow: () => IWindowController | undefined,
-) {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-  const { beginWindowDrag, endWindowDrag } = useWorkspaceEdgeDrop()
-
-  function onDragStart() {
-    const win = getWindow()
-    if (!win?.state?.id || desktopWorkspaceStore.overview) return
-    beginWindowDrag(win.state.id)
-  }
-
-  function onDragEnd(data: { left: number; top: number }) {
-    const win = getWindow()
-    const moved =
-      Boolean(win) &&
-      !desktopWorkspaceStore.overview &&
-      endWindowDrag(win)
-
-    if (!moved && win) {
-      win.actions.setPosition({ x: data.left, y: data.top })
-    }
-  }
-
-  return { onDragStart, onDragEnd }
-}

package/runtime/composables/useWorkspaceManager.ts

@@ -1,67 +0,0 @@
-import { useEventListener } from '@vueuse/core'
-import { useApplicationManager } from './useApplicationManager'
-import { useDesktopWorkspaceStore } from '../stores/storeDesktopWorkspace'
-import { collectWindowsOnWorkspace } from '../utils/utilWorkspaceWindows'
-
-/**
- * Keyboard + HTML5 drop handlers for workspace management (move windows between desktops).
- */
-export function useWorkspaceManager() {
-  const applicationManager = useApplicationManager()
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-  useEventListener(window, 'keydown', (e: KeyboardEvent) => {
-    if (e.key !== 'Escape') return
-    if (!desktopWorkspaceStore.overview) return
-    desktopWorkspaceStore.setOverview(false)
-  })
-
-  function onWorkspaceDragOver(e: DragEvent) {
-    if (!desktopWorkspaceStore.overview) return
-    e.preventDefault()
-  }
-
-  function onWorkspaceDrop(e: DragEvent, workspaceId: string) {
-    e.preventDefault()
-    if (!desktopWorkspaceStore.overview) return
-
-    const raw =
-      e.dataTransfer?.getData('text/plain') ||
-      e.dataTransfer?.getData('text') ||
-      ''
-    if (!raw) return
-
-    const win = applicationManager.getWindowOpenedId(raw)
-    win?.actions.setWorkspace(workspaceId)
-  }
-
-  /**
-   * Remove a virtual desktop: migrate its windows to the last remaining workspace
-   * (excluding the removed id), then drop the workspace from the list.
-   */
-  function removeWorkspace(workspaceId: string): boolean {
-    if (desktopWorkspaceStore.list.length <= 2) return false
-
-    const fallbackId = desktopWorkspaceStore.resolveWorkspaceFallback(workspaceId)
-    if (!fallbackId) return false
-
-    const activeId = desktopWorkspaceStore.active
-    const windows = collectWindowsOnWorkspace(
-      applicationManager.apps.values(),
-      workspaceId,
-      activeId,
-    )
-
-    for (const win of windows) {
-      win.actions.setWorkspace(fallbackId)
-    }
-
-    return desktopWorkspaceStore.removeWorkspace(workspaceId)
-  }
-
-  return {
-    onWorkspaceDragOver,
-    onWorkspaceDrop,
-    removeWorkspace,
-  }
-}

package/runtime/composables/useWorkspaceOverviewCapture.ts

@@ -1,92 +0,0 @@
-import { useDebounceFn } from '@vueuse/core'
-import { nextTick, ref, shallowRef, watch } from 'vue'
-import { useDesktopWorkspaceStore } from '@owdproject/core/runtime/stores/storeDesktopWorkspace'
-import { captureElementToCanvas } from '../utils/utilCaptureElementToCanvas'
-
-export type WorkspaceRootResolver = (
-  workspaceId: string,
-) => HTMLElement | null | undefined
-
-export type UseWorkspaceOverviewCaptureOptions = {
-  /** Delay before capturing after overview opens (ms). Default 150. */
-  debounceMs?: number
-  /** JPEG quality for thumbnail data URLs (0–1). Default 0.7. */
-  jpegQuality?: number
-  /** Passed through to html2canvas. */
-  captureOptions?: Record<string, unknown>
-}
-
-/**
- * Captures workspace desktop roots as JPEG data URLs while workspace overview is open.
- * Themes supply a resolver that maps each workspace id to its DOM root (e.g. a layer wrapping
- * {@link DesktopApplicationRender} with `workspace-filter`).
- */
-export function useWorkspaceOverviewCapture(
-  resolveWorkspaceRoot: WorkspaceRootResolver,
-  options: UseWorkspaceOverviewCaptureOptions = {},
-) {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-  const thumbnails = shallowRef(new Map<string, string>())
-  const isCapturing = ref(false)
-
-  const debounceMs = options.debounceMs ?? 150
-  const jpegQuality = options.jpegQuality ?? 0.7
-
-  async function captureWorkspace(workspaceId: string): Promise<string | null> {
-    const element = resolveWorkspaceRoot(workspaceId)
-    const canvas = await captureElementToCanvas(element, options.captureOptions)
-    if (!canvas) return null
-    return canvas.toDataURL('image/jpeg', jpegQuality)
-  }
-
-  async function refreshThumbnails() {
-    if (!desktopWorkspaceStore.overview) return
-
-    isCapturing.value = true
-    const next = new Map<string, string>()
-
-    try {
-      await nextTick()
-      const ids = [...desktopWorkspaceStore.list]
-      await Promise.all(
-        ids.map(async (id) => {
-          const dataUrl = await captureWorkspace(id)
-          if (dataUrl) next.set(id, dataUrl)
-        }),
-      )
-      thumbnails.value = next
-    } finally {
-      isCapturing.value = false
-    }
-  }
-
-  const scheduleRefresh = useDebounceFn(() => {
-    void refreshThumbnails()
-  }, debounceMs)
-
-  watch(
-    () => desktopWorkspaceStore.overview,
-    (open) => {
-      if (open) scheduleRefresh()
-      else thumbnails.value = new Map()
-    },
-  )
-
-  watch(
-    () => desktopWorkspaceStore.list.join('\0'),
-    () => {
-      if (desktopWorkspaceStore.overview) scheduleRefresh()
-    },
-  )
-
-  function thumbnailFor(workspaceId: string): string | undefined {
-    return thumbnails.value.get(workspaceId)
-  }
-
-  return {
-    thumbnails,
-    isCapturing,
-    refreshThumbnails,
-    thumbnailFor,
-  }
-}