@owdproject/core 3.4.0 → 4.0.0-alpha.4

package/runtime/composables/useWorkspaceOverviewLiveScale.ts

@@ -1,151 +0,0 @@
-import type { CSSProperties, Ref } from 'vue'
-import {
-  nextTick,
-  onScopeDispose,
-  readonly,
-  shallowRef,
-  watch,
-} from 'vue'
-import { useDesktopWorkspaceStore } from '@owdproject/core/runtime/stores/storeDesktopWorkspace'
-
-export type WorkspaceStageSize = {
-  width: number
-  height: number
-}
-
-export type WorkspaceOverviewLiveScaleOptions = {
-  /** Upper bound for scale (default 1). */
-  maxScale?: number
-}
-
-export type WorkspaceOverviewInnerStyleOptions =
-  WorkspaceOverviewLiveScaleOptions & {
-    transformOrigin?: string
-  }
-
-/**
- * Fit factor to show a 1:1 shell stage inside a panel viewport without clipping.
- */
-export function computeScaleToFit(
-  panelWidth: number,
-  panelHeight: number,
-  stageWidth: number,
-  stageHeight: number,
-  options?: WorkspaceOverviewLiveScaleOptions,
-): number {
-  if (
-    panelWidth <= 0 ||
-    panelHeight <= 0 ||
-    stageWidth <= 0 ||
-    stageHeight <= 0
-  ) {
-    return 1
-  }
-
-  const scale = Math.min(panelWidth / stageWidth, panelHeight / stageHeight)
-  const maxScale = options?.maxScale ?? 1
-  return Math.min(scale, maxScale)
-}
-
-/**
- * Live DOM workspace overview: measure shell stage, scale desktop roots to fit cards.
- */
-export function useWorkspaceOverviewLiveScale(
-  shellStageRef: Ref<HTMLElement | null | undefined>,
-) {
-  const desktopWorkspaceStore = useDesktopWorkspaceStore()
-  const stageSize = shallowRef<WorkspaceStageSize>({ width: 0, height: 0 })
-
-  let resizeObserver: ResizeObserver | null = null
-
-  function readStageSize() {
-    const el = shellStageRef.value
-    if (!el) {
-      stageSize.value = { width: 0, height: 0 }
-      return
-    }
-    stageSize.value = {
-      width: el.clientWidth,
-      height: el.clientHeight,
-    }
-  }
-
-  function stopObserving() {
-    resizeObserver?.disconnect()
-    resizeObserver = null
-  }
-
-  function startObserving() {
-    stopObserving()
-    const el = shellStageRef.value
-    if (!el || typeof ResizeObserver === 'undefined') return
-
-    readStageSize()
-    resizeObserver = new ResizeObserver(() => readStageSize())
-    resizeObserver.observe(el)
-  }
-
-  watch(
-    () => desktopWorkspaceStore.overview,
-    (open) => {
-      if (open) {
-        void nextTick(() => startObserving())
-      } else {
-        stopObserving()
-        stageSize.value = { width: 0, height: 0 }
-      }
-    },
-  )
-
-  watch(shellStageRef, (el) => {
-    if (desktopWorkspaceStore.overview && el) {
-      void nextTick(() => startObserving())
-    }
-  })
-
-  onScopeDispose(stopObserving)
-
-  function scaleToFit(
-    panelEl: HTMLElement | null | undefined,
-    options?: WorkspaceOverviewLiveScaleOptions,
-  ): number {
-    if (!panelEl) return 1
-    const { width: stageWidth, height: stageHeight } = stageSize.value
-    if (stageWidth <= 0 || stageHeight <= 0) return 1
-
-    return computeScaleToFit(
-      panelEl.clientWidth,
-      panelEl.clientHeight,
-      stageWidth,
-      stageHeight,
-      options,
-    )
-  }
-
-  function innerOverviewStyle(
-    panelEl: HTMLElement | null | undefined,
-    options?: WorkspaceOverviewInnerStyleOptions,
-  ): CSSProperties | undefined {
-    if (!desktopWorkspaceStore.overview) return undefined
-
-    const { width: stageWidth, height: stageHeight } = stageSize.value
-    if (stageWidth <= 0 || stageHeight <= 0) return undefined
-
-    const scale = scaleToFit(panelEl, options)
-    const transformOrigin = options?.transformOrigin ?? 'top left'
-
-    return {
-      width: `${stageWidth}px`,
-      height: `${stageHeight}px`,
-      transform: `scale(${scale})`,
-      transformOrigin,
-    }
-  }
-
-  return {
-    stageSize: readonly(stageSize),
-    scaleToFit,
-    innerOverviewStyle,
-    refreshStageSize: readStageSize,
-  }
-}

package/runtime/constants/desktopShellKeys.ts

@@ -1,12 +0,0 @@
-import type { InjectionKey } from 'vue'
-import type { DesktopDialogProvider } from '../dialogs/desktopDialogProvider'
-
-export type DesktopToggleWindowMaximizeFn = (
-  win: IWindowController | undefined,
-) => boolean
-
-export const DESKTOP_DIALOG_PROVIDER_KEY: InjectionKey<DesktopDialogProvider> =
-  Symbol('desktop-dialog-provider')
-
-export const DESKTOP_TOGGLE_WINDOW_MAXIMIZE_KEY: InjectionKey<DesktopToggleWindowMaximizeFn> =
-  Symbol('desktop-toggle-window-maximize')

package/runtime/constants/shellLayout.ts

@@ -1,5 +0,0 @@
-/** Viewport band (px) where a window drag targets the adjacent workspace. */
-export const WORKSPACE_EDGE_DROP_PX = 72
-
-/** Viewport band (px) where a window drag targets a snap zone. */
-export const WINDOW_SNAP_EDGE_PX = 14

package/runtime/dialogs/desktopDialogProvider.ts

@@ -1,73 +0,0 @@
-/** Options for a yes/no confirmation (theme renders labels and chrome). */
-export interface DesktopConfirmDialogOptions {
-  title?: string
-  message: string
-  danger?: boolean
-  acceptLabel?: string
-  rejectLabel?: string
-  /**
-   * Theme-specific payload (e.g. delete dialog passes `toTrash` for slot templates).
-   */
-  extras?: Record<string, unknown>
-}
-
-/**
- * Cross-theme dialog API. Themes implement with PrimeVue, native dialogs, etc.
- * Callers pass user-facing strings (usually from i18n); implementations only render.
- */
-export interface DesktopDialogProvider {
-  confirm(options: DesktopConfirmDialogOptions): Promise<boolean>
-  alert(message: string, options?: { title?: string }): Promise<void>
-  prompt(message: string, defaultValue?: string): Promise<string | null>
-}
-
-function browserGlobals(): {
-  confirm: (message?: string) => boolean
-  alert: (message?: string) => void
-  prompt: (message?: string, defaultText?: string) => string | null
-} | null {
-  const g = globalThis as typeof globalThis & {
-    confirm?: (message?: string) => boolean
-    alert?: (message?: string) => void
-    prompt?: (message?: string, defaultText?: string) => string | null
-  }
-  if (typeof g.confirm !== 'function') return null
-  return {
-    confirm: g.confirm.bind(g),
-    alert:
-      typeof g.alert === 'function'
-        ? g.alert.bind(g)
-        : (m?: string) => {
-            void m
-          },
-    prompt:
-      typeof g.prompt === 'function'
-        ? g.prompt.bind(g)
-        : () => null,
-  }
-}
-
-export function createBrowserFallbackDialogProvider(): DesktopDialogProvider {
-  return {
-    async confirm(opts) {
-      if (import.meta.server) return false
-      const w = browserGlobals()
-      if (!w) return false
-      const text = [opts.title, opts.message].filter(Boolean).join('\n\n')
-      return w.confirm(text)
-    },
-    async alert(message, opts) {
-      if (import.meta.server) return
-      const w = browserGlobals()
-      if (!w) return
-      w.alert([opts?.title, message].filter(Boolean).join('\n\n'))
-    },
-    async prompt(message, defaultValue = '') {
-      if (import.meta.server) return null
-      const w = browserGlobals()
-      if (!w) return null
-      const v = w.prompt(message, defaultValue)
-      return v === null ? null : v
-    },
-  }
-}

package/runtime/internal/controllers/ApplicationController.ts

@@ -1,351 +0,0 @@
-import { nanoid } from 'nanoid'
-import { WindowController } from './WindowController'
-import { useApplicationManager } from '../../composables/useApplicationManager'
-import { useApplicationWindowsStore } from '../../stores/storeApplicationWindows'
-import { useApplicationMetaStore } from '../../stores/storeApplicationMeta'
-import { useTerminalManager } from '../../composables/useTerminalManager'
-import { debugLog, debugError } from '../../utils/utilDebug'
-import { useDesktopDefaultAppsStore } from '../../stores/storeDesktopDefaultApps'
-import { useDesktopWorkspaceStore } from '../../stores/storeDesktopWorkspace'
-import { useDesktopWindowStore } from '../../stores/storeDesktopWindow'
-import { shallowRef } from 'vue'
-import { unref } from 'vue'
-
-export class ApplicationController implements IApplicationController {
-  private readonly applicationManager: IApplicationManager
-  private readonly terminalManager: ITerminalManager
-
-  public readonly id
-  public readonly config
-  public readonly storeWindows
-
-  private readonly _windows = shallowRef(new Map<string, IWindowController>())
-
-  /** Reactive window count for Vue (class getters are not tracked). */
-  public readonly openWindowCount = shallowRef(0)
-
-  get windows(): Map<string, IWindowController> {
-    return this._windows.value
-  }
-
-  private replaceWindows(
-    mutator: (next: Map<string, IWindowController>) => void,
-  ) {
-    const next = new Map(this._windows.value)
-    mutator(next)
-    this._windows.value = next
-    this.openWindowCount.value = next.size
-  }
-
-  public isRunning = false
-
-  constructor(id: string, config: ApplicationConfig) {
-    this.applicationManager = useApplicationManager()
-    this.terminalManager = useTerminalManager()
-
-    this.id = id
-    this.config = config
-    this.storeWindows = useApplicationWindowsStore(id)
-  }
-
-  /** Lazy meta store — app modules should register state via `useApplicationMetaStore` before `defineDesktopApp`. */
-  get storeMeta() {
-    return useApplicationMetaStore(this.id)()
-  }
-
-  public async initApplication(): Promise<void> {
-    const desktopDefaultAppsStore = useDesktopDefaultAppsStore()
-
-    // provides
-
-    // set as default app for specific purposes
-    // todo improve this and move it in a store
-    if (this.config.provides) {
-      const existingDefault = desktopDefaultAppsStore.getDefaultApp(
-        this.config.provides.name,
-      )
-
-      if (!existingDefault) {
-        desktopDefaultAppsStore.setDefaultApp(
-          this.config.provides.name,
-          this,
-          this.config.provides.entry,
-        )
-
-        debugLog(
-          `${this.config.title} has been set as predefined app for "${this.config.provides.name}"`,
-        )
-      }
-    }
-
-    // terminal
-
-    if (this.config.commands) {
-      for (const commandKey of Object.keys(this.config.commands)) {
-        const meta = this.config.terminal?.[commandKey] ?? {}
-        this.terminalManager.addCommand({
-          applicationId: this.id,
-          name: commandKey,
-          ...meta,
-        })
-      }
-    }
-
-    // store
-
-    if (this.storeWindows.$persistedState) {
-      await this.storeWindows.$persistedState.isReady()
-    }
-
-    if (this.storeMeta.$persistedState) {
-      await this.storeMeta.$persistedState.isReady()
-    }
-
-    // set default meta values
-    // this.storeMeta.meta = this.config.meta ?? {}
-
-    // restore application state
-    await this.restoreApplication()
-
-    // once app is defined, always run "onReady"
-    if (typeof this.config.onReady === 'function') {
-      // todo transform in hook
-      this.config.onReady(this)
-    }
-  }
-
-  /**
-   * App always tries to restore previous windows
-   * and returns a boolean if it succeeded
-   */
-  public async restoreApplication() {
-    if (typeof this.config.onRestore === 'function') {
-      // todo transform in hook
-      await this.config.onRestore(this)
-    }
-
-    if (
-      !this.storeWindows.windows ||
-      Object.keys(this.storeWindows.windows).length === 0
-    ) {
-      return false
-    }
-
-    this.restoreWindows()
-
-    this.setRunning(true)
-
-    return true
-  }
-
-  private restoreWindows() {
-    Object.keys(this.storeWindows.windows).map((windowId) => {
-      const windowStore: WindowStoredState | undefined =
-        this.storeWindows.windows[windowId]
-
-      if (windowStore) {
-        this.openWindow(windowStore.model, windowStore, {
-          isRestoring: true,
-        })
-      }
-    })
-
-    this.normalizeWindowFocus()
-
-    debugLog('Windows have been restored', this.windows)
-  }
-
-  /** Ensure a single focused window after restore or stale persisted state. */
-  private normalizeWindowFocus() {
-    const allWindows = this.applicationManager?.windowsOpened?.value
-      ? Array.from(this.applicationManager.windowsOpened.value.values())
-      : Array.from(this.windows.values())
-
-    if (allWindows.length === 0) {
-      return
-    }
-
-    let topWindow: IWindowController | undefined
-    let topZ = -Infinity
-
-    for (const window of allWindows) {
-      window.setFocus(false)
-      const z = window.state.position?.z ?? 0
-      if (z >= topZ) {
-        topZ = z
-        topWindow = window
-      }
-    }
-
-    topWindow?.setFocus(true)
-  }
-
-  public openWindow(
-    model: string,
-    windowStoredState: WindowStoredState | undefined,
-    meta?: any,
-  ) {
-    const desktopWorkspaceStore = useDesktopWorkspaceStore()
-
-    if (!this.config.windows || !this.config.windows.hasOwnProperty(model)) {
-      debugError(`Window model "${model}" not found`)
-      return
-    }
-
-    if (!windowStoredState && this.config.singleton) {
-      const existing = this.getFirstWindowByModel(model)
-      if (existing) {
-        if (meta && typeof meta === 'object') {
-          Object.assign(existing.meta, meta)
-        }
-        if (!meta?.isRestoring) {
-          existing.actions.setActive(true)
-          existing.actions.bringToFront()
-        }
-        return existing
-      }
-    }
-
-    let windowId: string
-
-    if (!windowStoredState) {
-      windowId = `${model}-${nanoid(6)}`
-
-      const windowConfig: WindowConfig = this.config.windows[
-        model
-      ] as WindowConfig
-      const screenHeight = window.innerHeight
-      const configHeight = windowConfig.size?.height
-      const layoutHeight =
-        typeof configHeight === 'number'
-          ? configHeight
-          : typeof configHeight === 'string' && /^\d+$/.test(configHeight)
-            ? Number(configHeight)
-            : 240
-      const centerY = (screenHeight - layoutHeight) / 2
-      const positionY =
-        windowConfig.position?.y !== undefined
-          ? window.scrollY + windowConfig.position.y
-          : window.scrollY + centerY
-      const cascadeStep = 40
-      const cascadeOffset = this.getWindowsByModel(model).length * cascadeStep
-      const baseX = windowConfig.position?.x ?? 100
-      const desktopWindowStore = useDesktopWindowStore()
-      const initialZ = desktopWindowStore.incrementPositionZ()
-
-      const nextWindows = {
-        ...this.storeWindows.windows,
-        [windowId]: {
-          model,
-          state: {
-            id: windowId,
-            active: true,
-            focused: false,
-            position: {
-              x: baseX + cascadeOffset,
-              y: positionY + cascadeOffset,
-              z: initialZ,
-            },
-            createdAt: +new Date(),
-            workspace: desktopWorkspaceStore.resolveActiveWorkspaceId(),
-          },
-          meta,
-        },
-      }
-      this.storeWindows.windows = nextWindows
-
-      windowStoredState = this.storeWindows.windows[windowId]
-    } else {
-      // restore previous id if state is defined
-      windowId =
-        windowStoredState.state?.id ??
-        Object.keys(this.storeWindows.windows).find(
-          (key) => this.storeWindows.windows[key] === windowStoredState,
-        ) ??
-        `${model}-restored`
-    }
-
-    const windowConfig = this.config.windows[model] as WindowConfig
-
-    const windowController = new WindowController(
-      this,
-      model,
-      windowConfig,
-      windowStoredState!,
-    )
-
-    if (!meta?.isRestoring) {
-      windowController.actions.bringToFront()
-    }
-
-    this.replaceWindows((next) => {
-      next.set(windowId, windowController)
-    })
-
-    this.setRunning(true)
-
-    return windowController
-  }
-
-  public closeWindow(windowId: string) {
-    if (this.storeWindows.windows[windowId]) {
-      const nextWindows = { ...this.storeWindows.windows }
-      delete nextWindows[windowId]
-      this.storeWindows.windows = nextWindows
-    }
-
-    this.replaceWindows((next) => {
-      next.delete(windowId)
-    })
-
-    if (this.openWindowCount.value === 0) {
-      this.applicationManager.closeApp(this.id)
-    }
-  }
-
-  public closeAllWindows() {
-    this.storeWindows.windows = {}
-    this._windows.value = new Map()
-    this.openWindowCount.value = 0
-  }
-
-  get windowsOpened() {
-    return this.windows
-  }
-
-  public getWindowById(id: string): IWindowController[] {
-    return this.windows.get(id)
-  }
-
-  public getWindowsByModel(model: string): IWindowController[] {
-    return Array.from(this.windows.values()).filter((w) => w.model === model)
-  }
-
-  public getFirstWindowByModel(model: string): IWindowController | undefined {
-    return Array.from(this.windows.values()).find((w) => w.model === model)
-  }
-
-  public setRunning(value: boolean): void {
-    this.isRunning = value
-  }
-
-  // meta
-
-  get meta() {
-    return this.storeMeta.meta
-  }
-
-  getMeta(key: string) {
-    return this.meta[key]
-  }
-
-  setMeta(key: string, value: any) {
-    this.meta[key] = value
-  }
-
-  // commands
-
-  async execCommand(command: string): Promise<CommandOutput | void> {
-    return this.applicationManager.execAppCommand(this.id, command)
-  }
-}