@tooee/view 0.1.20 → 0.1.22

package/src/hooks/index.ts

@@ -1,4 +1,13 @@
 export { useContentLoader } from "./useContentLoader.js"
 export { useMarkState } from "./useMarkState.js"
 export { useViewCommands } from "./useViewCommands.js"
-export { useViewCommandContext } from "./useViewCommandContext.js"
+export {
+  createViewCommandContext,
+  useProvideViewCommandContext,
+  useViewCommandContext,
+} from "./useViewCommandContext.js"
+export type {
+  CreateViewCommandContextOptions,
+  ProvideViewCommandContextOptions,
+  ViewCommandContext,
+} from "./useViewCommandContext.js"

package/src/hooks/useContentLoader.ts

@@ -92,12 +92,18 @@ export function useContentLoader(contentProvider: ContentProvider, reloadTrigger
       setContent(current)
       setStreaming(true)
 
+      // Hold the iterator explicitly so cleanup can close it: a cleanup that
+      // only flips `cancelled` leaves a pending next() (and the provider's
+      // subprocess/file handle/network stream) alive until the next chunk.
+      const iterator = loaded[Symbol.asyncIterator]()
+
       ;(async () => {
         try {
-          for await (const chunk of loaded) {
-            if (cancelled) break
+          while (true) {
+            const result = await iterator.next()
+            if (cancelled || result.done) break
+            const chunk = result.value
             if (chunk.type === "marks") {
-              if (cancelled) break
               // Streamed mark set: merge by replacing any existing set with same namespace
               setProviderMarks((prev) => {
                 const filtered = prev.filter((s) => s.namespace !== chunk.set.namespace)
@@ -109,8 +115,8 @@ export function useContentLoader(contentProvider: ContentProvider, reloadTrigger
             setContent(current)
           }
         } catch (err) {
-          if (!cancelled && err instanceof Error) {
-            setError(err.message)
+          if (!cancelled) {
+            setError(err instanceof Error ? err.message : String(err))
           }
         } finally {
           if (!cancelled) {
@@ -121,6 +127,8 @@ export function useContentLoader(contentProvider: ContentProvider, reloadTrigger
 
       return () => {
         cancelled = true
+        // Close the iterator to release provider resources mid-stream.
+        Promise.resolve(iterator.return?.()).catch(() => {})
       }
     }
 
@@ -130,8 +138,8 @@ export function useContentLoader(contentProvider: ContentProvider, reloadTrigger
         .then((value) => {
           if (active) setContent(value)
         })
-        .catch((err: Error) => {
-          if (active) setError(err.message)
+        .catch((err: unknown) => {
+          if (active) setError(err instanceof Error ? err.message : String(err))
         })
       return () => {
         active = false

package/src/hooks/useViewCommandContext.ts

@@ -1,8 +1,123 @@
-import { useProvideCommandContext, useMode } from "@tooee/commands"
+import { useProvideCommandContextKey, useMode } from "@tooee/commands"
+import type { Mode } from "@tooee/commands"
 import type { NavigationState } from "@tooee/shell"
 import type { MarkSet } from "@tooee/marks"
 import type { AnyContent } from "../types.js"
 
+/** The `view` field contributed to the command context (see augmentation below). */
+export interface ViewCommandContext {
+  content: AnyContent
+  format: string
+  title?: string
+  data?: unknown
+  cursor: number | null
+  selection: { start: number; end: number } | null
+  mode: Mode
+  toggledIndices: Set<number>
+  reload: () => void
+  marks: {
+    setMarkSet: (set: MarkSet) => void
+    clearNamespace: (namespace: string) => void
+    clearAll: () => void
+    userMarks: MarkSet[]
+    providerMarks: MarkSet[]
+  }
+  /** Subview extras (e.g. activeRow/selectedRows for tables). */
+  [key: string]: unknown
+}
+
+declare module "@tooee/commands" {
+  interface CommandContext {
+    view: ViewCommandContext
+  }
+}
+
+const noop = () => {}
+
+type ViewNavigationContext = Pick<NavigationState, "cursor" | "selection" | "toggledIndices">
+
+export interface CreateViewCommandContextOptions {
+  /**
+   * Content represented by this command context. Custom/headless surfaces may
+   * omit it; the builder will synthesize a minimal custom content object.
+   */
+  content?: AnyContent
+  format?: string
+  title?: string
+  data?: unknown
+  nav?: ViewNavigationContext
+  cursor?: number | null
+  selection?: { start: number; end: number } | null
+  /** Caller-owned mode value. Prefer `useProvideViewCommandContext` in React so this is live. */
+  mode: Mode
+  toggledIndices?: Set<number>
+  reload?: () => void
+  marks?: Partial<ViewCommandContext["marks"]>
+  extras?: Record<string, unknown>
+}
+
+export type ProvideViewCommandContextOptions = Omit<CreateViewCommandContextOptions, "mode"> & {
+  /** Advanced override; normally omitted so the hook injects the live command mode. */
+  mode?: Mode
+}
+
+export function createViewCommandContext({
+  content,
+  format,
+  title,
+  data,
+  nav,
+  cursor,
+  selection,
+  mode,
+  toggledIndices,
+  reload,
+  marks,
+  extras,
+}: CreateViewCommandContextOptions): ViewCommandContext {
+  const resolvedFormat = format ?? content?.format ?? "custom"
+  const resolvedContent: AnyContent =
+    content ??
+    ({
+      format: resolvedFormat,
+      data,
+      title,
+    } satisfies AnyContent)
+
+  return {
+    ...extras,
+    content: resolvedContent,
+    format: resolvedFormat,
+    title: title ?? content?.title,
+    data: data ?? ("data" in resolvedContent ? resolvedContent.data : undefined),
+    cursor: cursor ?? nav?.cursor ?? null,
+    selection: selection ?? nav?.selection ?? null,
+    mode,
+    toggledIndices: toggledIndices ?? nav?.toggledIndices ?? new Set<number>(),
+    reload: reload ?? noop,
+    marks: {
+      setMarkSet: marks?.setMarkSet ?? noop,
+      clearNamespace: marks?.clearNamespace ?? noop,
+      clearAll: marks?.clearAll ?? noop,
+      userMarks: marks?.userMarks ?? [],
+      providerMarks: marks?.providerMarks ?? [],
+    },
+  }
+}
+
+export function useProvideViewCommandContext(
+  options: ProvideViewCommandContextOptions | (() => ProvideViewCommandContextOptions),
+) {
+  const mode = useMode()
+  useProvideCommandContextKey("view", () => {
+    const resolvedOptions = typeof options === "function" ? options() : options
+    return createViewCommandContext({
+      ...resolvedOptions,
+      mode: resolvedOptions.mode ?? mode,
+    })
+  })
+}
+
 interface UseViewCommandContextParams {
   content: AnyContent
   nav: NavigationState
@@ -27,24 +142,17 @@ export function useViewCommandContext({
   clearAllUserMarks,
   extras,
 }: UseViewCommandContextParams) {
-  const mode = useMode()
-  useProvideCommandContext(() => ({
-    view: {
-      content,
-      format: content.format,
-      cursor: nav.cursor,
-      selection: nav.selection,
-      mode,
-      toggledIndices: nav.toggledIndices,
-      reload,
-      marks: {
-        setMarkSet,
-        clearNamespace: clearMarkNamespace,
-        clearAll: clearAllUserMarks,
-        userMarks,
-        providerMarks,
-      },
-      ...extras,
+  useProvideViewCommandContext({
+    content,
+    nav,
+    reload,
+    marks: {
+      setMarkSet,
+      clearNamespace: clearMarkNamespace,
+      clearAll: clearAllUserMarks,
+      userMarks,
+      providerMarks,
     },
-  }))
+    extras,
+  })
 }

package/src/index.ts

@@ -10,6 +10,16 @@ export {
 } from "./default-provider.js"
 export { listDirectoryFiles } from "./directory-provider.js"
 export type { DirectoryEntry } from "./directory-provider.js"
+export {
+  createViewCommandContext,
+  useProvideViewCommandContext,
+  useViewCommandContext,
+} from "./hooks/useViewCommandContext.js"
+export type {
+  CreateViewCommandContextOptions,
+  ProvideViewCommandContextOptions,
+  ViewCommandContext,
+} from "./hooks/useViewCommandContext.js"
 export type {
   AnyContent,
   Content,
@@ -25,3 +35,5 @@ export type {
   TableRow,
 } from "./types.js"
 export { getTextContent, isBuiltinContent, isCustomContent } from "./types.js"
+export { CodeBlockChrome } from "@tooee/renderers"
+export type { CodeBlockRenderer, CodeBlockRendererProps, CodeBlockHScroll } from "@tooee/renderers"

package/src/launch.tsx

@@ -1,5 +1,6 @@
 import { launchCli } from "@tooee/shell"
 import type { ActionDefinition } from "@tooee/commands"
+import type { CodeBlockRenderer } from "@tooee/renderers"
 import { View } from "./View.js"
 import { DirectoryView } from "./DirectoryView.js"
 import type { ContentProvider, ContentRenderer } from "./types.js"
@@ -8,6 +9,12 @@ export interface ViewLaunchOptions {
   contentProvider: ContentProvider
   actions?: ActionDefinition[]
   renderers?: Record<string, ContentRenderer>
+  /**
+   * Custom renderers for fenced code blocks in markdown content, keyed by
+   * fence type (first word of the fence info string, case-insensitive).
+   * Unmatched types fall back to the default syntax-highlighted code block.
+   */
+  codeBlockRenderers?: Record<string, CodeBlockRenderer>
 }
 
 export interface DirectoryLaunchOptions {
@@ -21,6 +28,7 @@ export async function launch(options: ViewLaunchOptions): Promise<void> {
       contentProvider={options.contentProvider}
       actions={options.actions}
       renderers={options.renderers}
+      codeBlockRenderers={options.codeBlockRenderers}
     />,
   )
 }

package/src/types.ts

@@ -57,6 +57,16 @@ export interface ContentRendererProps {
   selectionEnd?: number
   /** Combined mark state (nav + provider + user marks) */
   marks?: MarkState
+  /**
+   * Select a row by index — the mouse equivalent of the keyboard cursor move.
+   * A custom renderer that has a notion of rows should call this from its own
+   * `onMouseDown`/`onRowClick` handlers to make left-click select a row, the
+   * same way the built-in code/markdown/table views do. Selection is a no-op
+   * while a modal overlay is open (the host guards it), so renderers can wire
+   * it unconditionally. Renderers that own a `RowDocumentRenderable` can map a
+   * click's screen-Y to a row via its `getRowAtScreenY(event.y)` helper.
+   */
+  onSelectRow?: (index: number) => void
 }
 
 export type ContentRenderer = (props: ContentRendererProps) => ReactNode