@lijian-ui/dsh-file-manager 0.2.2 → 0.2.4

package/src/client/drag/file-drag.ts

@@ -1,67 +1,67 @@
-/**
- * Pure drag-to-composer helpers shared by the explorer rows (the drag
- * source) and the composer dock inlay (the drop target): the custom MIME
- * type, the drag-state detector, and the draft-splicing rule. Deliberately
- * framework-free so the splicing math is unit-testable in isolation.
- *
- * The composer host only accepts OS image drops (its document-level drop
- * handler checks `dataTransfer.types` for `Files` and routes through the
- * image pipeline), so a workspace file needs its own MIME. A plain relative
- * path is inserted into the draft — the agent reads the file through its
- * existing tools without any prefix grammar.
- * @module dsh-filemgr/client/drag/file-drag
- */
-
-/** Custom MIME carrying a workspace-relative file path. */
-export const FILE_DRAG_MIME = 'application/x-dsh-file'
-
-/**
- * Whether a drag event carries our file payload.
- * @param types - the live `dataTransfer.types` list (read-only during drag).
- * @returns true when our MIME is present.
- */
-export function hasFileDrag(types: readonly string[] | undefined): boolean {
-  return types !== undefined && types.includes(FILE_DRAG_MIME)
-}
-
-/**
- * Whether a drop payload is a plausible workspace-relative path. The custom
- * MIME only proves the drag carries *some* string — a foreign page can set it
- * too, so the payload itself is validated before it reaches the draft:
- * relative POSIX shape only; no absolute paths, no '..' segments, no
- * backslashes, no control characters, and a sane length.
- * @param path - the raw payload from dataTransfer.
- * @returns true when the payload is safe to splice into the draft.
- */
-export function isValidFileDragPayload(path: string): boolean {
-  if (path === '' || path.length > 512) return false
-  if (path.startsWith('/') || path.includes('\\')) return false
-  // eslint-disable-next-line no-control-regex
-  if (/[\x00-\x1f\x7f]/.test(path)) return false
-  if (path.split('/').some(segment => segment === '..')) return false
-  return true
-}
-
-/**
- * Splice a workspace-relative path into a composer draft at the caret.
- *
- * Separator rule: one space is added before the path unless the caret sits
- * at the start of the draft or right after whitespace; one space is added
- * after the path unless the caret sits at the end of the draft or right
- * before whitespace. Empty path or an out-of-range caret are no-ops.
- *
- * @param draft - the current draft text.
- * @param path - the relative path to insert.
- * @param caret - insertion offset (default: the end of the draft).
- * @returns the next draft; the caller owns writing it through the input
- * facade.
- */
-export function insertPathIntoDraft(draft: string, path: string, caret?: number): string {
-  if (path === '') return draft
-  const at = caret === undefined ? draft.length : Math.min(Math.max(caret, 0), draft.length)
-  const before = draft.slice(0, at)
-  const after = draft.slice(at)
-  const needBefore = before !== '' && !/\s$/.test(before)
-  const needAfter = after !== '' && !/^\s/.test(after)
-  return before + (needBefore ? ' ' : '') + path + (needAfter ? ' ' : '') + after
-}
+/**
+ * Pure drag-to-composer helpers shared by the explorer rows (the drag
+ * source) and the composer dock inlay (the drop target): the custom MIME
+ * type, the drag-state detector, and the draft-splicing rule. Deliberately
+ * framework-free so the splicing math is unit-testable in isolation.
+ *
+ * The composer host only accepts OS image drops (its document-level drop
+ * handler checks `dataTransfer.types` for `Files` and routes through the
+ * image pipeline), so a workspace file needs its own MIME. A plain relative
+ * path is inserted into the draft — the agent reads the file through its
+ * existing tools without any prefix grammar.
+ * @module dsh-filemgr/client/drag/file-drag
+ */
+
+/** Custom MIME carrying a workspace-relative file path. */
+export const FILE_DRAG_MIME = 'application/x-dsh-file'
+
+/**
+ * Whether a drag event carries our file payload.
+ * @param types - the live `dataTransfer.types` list (read-only during drag).
+ * @returns true when our MIME is present.
+ */
+export function hasFileDrag(types: readonly string[] | undefined): boolean {
+  return types !== undefined && types.includes(FILE_DRAG_MIME)
+}
+
+/**
+ * Whether a drop payload is a plausible workspace-relative path. The custom
+ * MIME only proves the drag carries *some* string — a foreign page can set it
+ * too, so the payload itself is validated before it reaches the draft:
+ * relative POSIX shape only; no absolute paths, no '..' segments, no
+ * backslashes, no control characters, and a sane length.
+ * @param path - the raw payload from dataTransfer.
+ * @returns true when the payload is safe to splice into the draft.
+ */
+export function isValidFileDragPayload(path: string): boolean {
+  if (path === '' || path.length > 512) return false
+  if (path.startsWith('/') || path.includes('\\')) return false
+  // eslint-disable-next-line no-control-regex
+  if (/[\x00-\x1f\x7f]/.test(path)) return false
+  if (path.split('/').some(segment => segment === '..')) return false
+  return true
+}
+
+/**
+ * Splice a workspace-relative path into a composer draft at the caret.
+ *
+ * Separator rule: one space is added before the path unless the caret sits
+ * at the start of the draft or right after whitespace; one space is added
+ * after the path unless the caret sits at the end of the draft or right
+ * before whitespace. Empty path or an out-of-range caret are no-ops.
+ *
+ * @param draft - the current draft text.
+ * @param path - the relative path to insert.
+ * @param caret - insertion offset (default: the end of the draft).
+ * @returns the next draft; the caller owns writing it through the input
+ * facade.
+ */
+export function insertPathIntoDraft(draft: string, path: string, caret?: number): string {
+  if (path === '') return draft
+  const at = caret === undefined ? draft.length : Math.min(Math.max(caret, 0), draft.length)
+  const before = draft.slice(0, at)
+  const after = draft.slice(at)
+  const needBefore = before !== '' && !/\s$/.test(before)
+  const needAfter = after !== '' && !/^\s/.test(after)
+  return before + (needBefore ? ' ' : '') + path + (needAfter ? ' ' : '') + after
+}

package/src/client/drag.ts

@@ -1,154 +1,154 @@
-/**
- * Framework-free drag machinery shared by the React hook (useResizableSplit)
- * and the DOM layout controller: one pointer-down handler that owns capture,
- * the rAF-flush loop, the e.buttons === 0 fallback, every end path, and the
- * drag styles. Pure DOM — no React, so both callers run the exact same
- * smoothness core (FileManager's useResizableSplit architecture, re-implemented).
- * @module dsh-filemgr/client/drag
- */
-
-export interface DragStartOptions {
-  /** Drag left = grow (handle on the left edge of its container). */
-  reverse: boolean
-  /** Width at drag start (read at pointer-down time). */
-  getStartWidth: () => number
-  /** Clamped width from the raw delta (px mode adds deltaX directly). */
-  compute: (startWidth: number, deltaX: number) => number
-  /** Per-frame flush (rAF-merged; called at most once per frame). */
-  onFrame: (width: number) => void
-  /** Final commit (also fired on every end path). */
-  onEnd: (width: number) => void
-}
-
-/** Whether a pointer event is the primary (left) button or touch. */
-function isPrimaryPointer(event: PointerEvent): boolean {
-  return event.pointerType === 'touch' || event.button === 0
-}
-
-/**
- * Handle one pointer-down: wire capture + window listeners, run the rAF
- * loop, and end on any of the five termination paths. Call from a
- * onPointerDown handler (React or plain DOM).
- * @param event - the raw pointerdown event.
- * @param el - the handle element (capture target + reverse marker source).
- * @param opts - drag behavior.
- * @returns a disposer (idempotent; also called internally on end).
- */
-export function handlePointerDragStart(event: PointerEvent, el: HTMLElement, opts: DragStartOptions): () => void {
-  if (!isPrimaryPointer(event)) return () => {}
-  event.preventDefault()
-
-  const startX = event.clientX
-  const startWidth = opts.getStartWidth()
-  const pointerId = event.pointerId
-  const reverse = opts.reverse
-
-  let rafId: number | null = null
-  let pendingWidth: number | null = null
-  let latestWidth = startWidth
-  let isDragging = true
-  let cleanup: (() => void) | null = null
-
-  const flushPending = (): void => {
-    if (pendingWidth === null) return
-    latestWidth = pendingWidth
-    opts.onFrame(pendingWidth)
-  }
-
-  const addWindowListener = <K extends keyof WindowEventMap>(
-    key: K,
-    handler: (e: WindowEventMap[K]) => void,
-  ): (() => void) => {
-    window.addEventListener(key, handler)
-    return () => window.removeEventListener(key, handler)
-  }
-
-  const computeWidth = (clientX: number): number => {
-    const deltaX = reverse ? startX - clientX : clientX - startX
-    return opts.compute(startWidth, deltaX)
-  }
-
-  const finishDrag = (e?: PointerEvent | MouseEvent | FocusEvent): void => {
-    if (!isDragging) return
-    isDragging = false
-    if (rafId !== null) {
-      cancelAnimationFrame(rafId)
-      rafId = null
-    }
-    flushPending()
-    let finalWidth = latestWidth
-    if (e !== undefined && 'clientX' in e && typeof e.clientX === 'number') {
-      finalWidth = computeWidth(e.clientX)
-    }
-    opts.onEnd(finalWidth)
-    cleanup?.()
-  }
-
-  const handlePointerMove = (e: PointerEvent): void => {
-    if (!isDragging) return
-    if (e.buttons === 0) {
-      // Lost pointerup (capture steal / release outside): end now.
-      finishDrag(e)
-      return
-    }
-    pendingWidth = computeWidth(e.clientX)
-    if (rafId === null) {
-      rafId = requestAnimationFrame(() => {
-        rafId = null
-        flushPending()
-      })
-    }
-  }
-  const handlePointerUp = (e: PointerEvent): void => finishDrag(e)
-  const handlePointerCancel = (e: PointerEvent): void => finishDrag(e)
-  const handleMouseUp = (e: MouseEvent): void => finishDrag(e)
-  const handleLostCapture = (): void => finishDrag()
-
-  // Drag styles: no text selection, col-resize cursor, disable transitions.
-  const previousUserSelect = document.body.style.userSelect
-  const previousCursor = document.body.style.cursor
-  document.body.style.userSelect = 'none'
-  document.body.style.cursor = 'col-resize'
-  const frame = el.closest('[data-dsh-frame]')
-  frame?.setAttribute('data-filemgr-instant', '')
-
-  const restore = (): void => {
-    document.body.style.userSelect = previousUserSelect
-    document.body.style.cursor = previousCursor
-    frame?.removeAttribute('data-filemgr-instant')
-  }
-
-  if (el.setPointerCapture) {
-    try {
-      el.setPointerCapture(pointerId)
-      el.addEventListener('lostpointercapture', handleLostCapture)
-    } catch {
-      // capture failed; the window listeners cover the drag
-    }
-  }
-
-  const releaseCapture = (): void => {
-    try {
-      if (el.releasePointerCapture && el.hasPointerCapture?.(pointerId)) {
-        el.releasePointerCapture(pointerId)
-      }
-    } catch {
-      // already released
-    }
-    el.removeEventListener('lostpointercapture', handleLostCapture)
-  }
-
-  const listeners = [
-    addWindowListener('pointermove', handlePointerMove),
-    addWindowListener('pointerup', handlePointerUp),
-    addWindowListener('pointercancel', handlePointerCancel),
-    addWindowListener('mouseup', handleMouseUp),
-    addWindowListener('blur', () => finishDrag()),
-  ]
-  cleanup = () => {
-    restore()
-    releaseCapture()
-    for (const dispose of listeners) dispose()
-  }
-  return cleanup
-}
+/**
+ * Framework-free drag machinery shared by the React hook (useResizableSplit)
+ * and the DOM layout controller: one pointer-down handler that owns capture,
+ * the rAF-flush loop, the e.buttons === 0 fallback, every end path, and the
+ * drag styles. Pure DOM — no React, so both callers run the exact same
+ * smoothness core (FileManager's useResizableSplit architecture, re-implemented).
+ * @module dsh-filemgr/client/drag
+ */
+
+export interface DragStartOptions {
+  /** Drag left = grow (handle on the left edge of its container). */
+  reverse: boolean
+  /** Width at drag start (read at pointer-down time). */
+  getStartWidth: () => number
+  /** Clamped width from the raw delta (px mode adds deltaX directly). */
+  compute: (startWidth: number, deltaX: number) => number
+  /** Per-frame flush (rAF-merged; called at most once per frame). */
+  onFrame: (width: number) => void
+  /** Final commit (also fired on every end path). */
+  onEnd: (width: number) => void
+}
+
+/** Whether a pointer event is the primary (left) button or touch. */
+function isPrimaryPointer(event: PointerEvent): boolean {
+  return event.pointerType === 'touch' || event.button === 0
+}
+
+/**
+ * Handle one pointer-down: wire capture + window listeners, run the rAF
+ * loop, and end on any of the five termination paths. Call from a
+ * onPointerDown handler (React or plain DOM).
+ * @param event - the raw pointerdown event.
+ * @param el - the handle element (capture target + reverse marker source).
+ * @param opts - drag behavior.
+ * @returns a disposer (idempotent; also called internally on end).
+ */
+export function handlePointerDragStart(event: PointerEvent, el: HTMLElement, opts: DragStartOptions): () => void {
+  if (!isPrimaryPointer(event)) return () => {}
+  event.preventDefault()
+
+  const startX = event.clientX
+  const startWidth = opts.getStartWidth()
+  const pointerId = event.pointerId
+  const reverse = opts.reverse
+
+  let rafId: number | null = null
+  let pendingWidth: number | null = null
+  let latestWidth = startWidth
+  let isDragging = true
+  let cleanup: (() => void) | null = null
+
+  const flushPending = (): void => {
+    if (pendingWidth === null) return
+    latestWidth = pendingWidth
+    opts.onFrame(pendingWidth)
+  }
+
+  const addWindowListener = <K extends keyof WindowEventMap>(
+    key: K,
+    handler: (e: WindowEventMap[K]) => void,
+  ): (() => void) => {
+    window.addEventListener(key, handler)
+    return () => window.removeEventListener(key, handler)
+  }
+
+  const computeWidth = (clientX: number): number => {
+    const deltaX = reverse ? startX - clientX : clientX - startX
+    return opts.compute(startWidth, deltaX)
+  }
+
+  const finishDrag = (e?: PointerEvent | MouseEvent | FocusEvent): void => {
+    if (!isDragging) return
+    isDragging = false
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId)
+      rafId = null
+    }
+    flushPending()
+    let finalWidth = latestWidth
+    if (e !== undefined && 'clientX' in e && typeof e.clientX === 'number') {
+      finalWidth = computeWidth(e.clientX)
+    }
+    opts.onEnd(finalWidth)
+    cleanup?.()
+  }
+
+  const handlePointerMove = (e: PointerEvent): void => {
+    if (!isDragging) return
+    if (e.buttons === 0) {
+      // Lost pointerup (capture steal / release outside): end now.
+      finishDrag(e)
+      return
+    }
+    pendingWidth = computeWidth(e.clientX)
+    if (rafId === null) {
+      rafId = requestAnimationFrame(() => {
+        rafId = null
+        flushPending()
+      })
+    }
+  }
+  const handlePointerUp = (e: PointerEvent): void => finishDrag(e)
+  const handlePointerCancel = (e: PointerEvent): void => finishDrag(e)
+  const handleMouseUp = (e: MouseEvent): void => finishDrag(e)
+  const handleLostCapture = (): void => finishDrag()
+
+  // Drag styles: no text selection, col-resize cursor, disable transitions.
+  const previousUserSelect = document.body.style.userSelect
+  const previousCursor = document.body.style.cursor
+  document.body.style.userSelect = 'none'
+  document.body.style.cursor = 'col-resize'
+  const frame = el.closest('[data-dsh-frame]')
+  frame?.setAttribute('data-filemgr-instant', '')
+
+  const restore = (): void => {
+    document.body.style.userSelect = previousUserSelect
+    document.body.style.cursor = previousCursor
+    frame?.removeAttribute('data-filemgr-instant')
+  }
+
+  if (el.setPointerCapture) {
+    try {
+      el.setPointerCapture(pointerId)
+      el.addEventListener('lostpointercapture', handleLostCapture)
+    } catch {
+      // capture failed; the window listeners cover the drag
+    }
+  }
+
+  const releaseCapture = (): void => {
+    try {
+      if (el.releasePointerCapture && el.hasPointerCapture?.(pointerId)) {
+        el.releasePointerCapture(pointerId)
+      }
+    } catch {
+      // already released
+    }
+    el.removeEventListener('lostpointercapture', handleLostCapture)
+  }
+
+  const listeners = [
+    addWindowListener('pointermove', handlePointerMove),
+    addWindowListener('pointerup', handlePointerUp),
+    addWindowListener('pointercancel', handlePointerCancel),
+    addWindowListener('mouseup', handleMouseUp),
+    addWindowListener('blur', () => finishDrag()),
+  ]
+  cleanup = () => {
+    restore()
+    releaseCapture()
+    for (const dispose of listeners) dispose()
+  }
+  return cleanup
+}

package/src/client/file-source.ts

@@ -56,3 +56,37 @@ export function registerFileReferenceSource(ctx: ClientContext): () => void {
     return () => {}
   }
 }
+
+/** The roster name Excel-selection chips address (see reference.ts). */
+export const SHEET_SOURCE_NAME = 'sheet'
+
+/**
+ * Register the inert `sheet` reference source (codec only). Mirrors the
+ * `file` source: it isn't a menu participant, its only job is to let the
+ * shell's submit pipeline serialize the `相对路径!Sheet名!Range` chip text.
+ * Inert — no pick, no menu candidates; Excel references are minted by
+ * reference.ts's appendSheetChip, purely for chip appearance.
+ */
+export function registerSheetReferenceSource(ctx: ClientContext): () => void {
+  const inputTriggers = (ctx.get as (name: string) => unknown)('inputTriggers') as
+    | { registerSource(src: InputTriggerSource): () => void }
+    | undefined
+  if (inputTriggers === undefined) return () => {}
+  const source: InputTriggerSource = {
+    trigger: '@',
+    name: SHEET_SOURCE_NAME,
+    candidates: async () => [],
+    onPick: () => undefined,
+    codec: {
+      clipboardText: (ref) => ref,
+      serialize: (ref, _signal) => Promise.resolve(ref),
+    },
+  }
+  try {
+    return inputTriggers.registerSource(source)
+  } catch (error) {
+    // Duplicate registration (HMR remount) is not a failure.
+    console.warn('[dsh-filemgr] sheet reference source already registered:', error)
+    return () => {}
+  }
+}

package/src/client/fileType.ts

@@ -86,6 +86,16 @@ export function isEditableType(type: PreviewContentType): boolean {
   return type === 'markdown' || type === 'html' || type === 'code' || type === 'csv' || type === 'text'
 }
 
+/** Whether a file path names an editable .xlsx (the only editable excel kind). */
+export function isExcelEditablePath(path: string): boolean {
+  return path.toLowerCase().endsWith('.xlsx')
+}
+
+/** Whether a file path names an editable .pptx (the only editable ppt kind). */
+export function isPptEditablePath(path: string): boolean {
+  return path.toLowerCase().endsWith('.pptx')
+}
+
 /** Whether the type reads its content as text (vs image data URL). */
 export function isTextType(type: PreviewContentType): boolean {
   return type !== 'image' && type !== 'pdf' && type !== 'word' && type !== 'excel'
@@ -117,13 +127,30 @@ export function parentRel(path: string): string {
 }
 
 /**
- * The streaming URL a pdf tab renders: the host raw route serves the bytes
- * with mime application/pdf, so the preview iframe loads them directly — no
- * base64 round-trip and no read-size cap. The nonce defeats browser caching
- * when the tab is refreshed after the file changed on disk.
+ * The streaming URL a pdf/office tab renders: the host raw route serves the
+ * bytes with the derived mime, so the preview iframe / viewer loads them
+ * directly — no base64 round-trip and no read-size cap. The nonce defeats
+ * browser caching when the tab is refreshed after the file changed on disk.
+ */
+export function rawPreviewUrl(root: string, path: string, nonce: number): string {
+  return `/filemgr/raw?root=${encodeURIComponent(root)}&path=${encodeURIComponent(path)}&v=${nonce}`
+}
+
+/**
+ * Whether a content type streams its bytes through the raw route (never the
+ * /read text path): pdf and the office kinds. The tab's `content` is the
+ * raw-route URL; the viewer fetches it into bytes itself.
+ */
+export function isStreamedType(type: PreviewContentType): boolean {
+  return type === 'pdf' || type === 'word' || type === 'excel' || type === 'ppt'
+}
+
+/**
+ * The streaming URL a pdf tab renders (mime application/pdf; the preview
+ * iframe loads it directly). Kept as the pdf-specific alias of rawPreviewUrl.
  *
  * Contributed by EricWang1358 (#239).
  */
 export function pdfPreviewUrl(root: string, path: string, nonce: number): string {
-  return `/filemgr/raw?root=${encodeURIComponent(root)}&path=${encodeURIComponent(path)}&v=${nonce}`
+  return rawPreviewUrl(root, path, nonce)
 }