@workerdeck/ui 0.9.0 → 0.12.0

package/build/workspace.d.mts

@@ -0,0 +1,226 @@
+import { r as SessionPanelProps } from "./SessionPanel-Dy9lQrOV.mjs";
+import * as _$react from "react";
+import { CSSProperties } from "react";
+import { OpenFile, UseHostFileSearchResult, UseHostFileTreeResult } from "@workerdeck/react";
+import { WorkerDeckClient } from "@workerdeck/client";
+
+//#region src/components/agent/SessionWorkspace.d.ts
+interface SessionWorkspaceProps {
+  client: WorkerDeckClient;
+  sessionId: string | undefined;
+  /** Passed straight through to {@link SessionPanel} — including the render-prop
+   * form that claims the session-actions menu. */
+  header?: SessionPanelProps['header'];
+  /**
+   * Panel seams the workspace does not interpret, forwarded verbatim.
+   *
+   * They are listed rather than spread so the workspace stays explicit about
+   * what it passes on: the panel owns the session's one attach, and a seam that
+   * silently arrived here would be a second place to look for why a session
+   * renders the way it does.
+   */
+  transcriptVariant?: SessionPanelProps['transcriptVariant'];
+  transcriptDensity?: SessionPanelProps['transcriptDensity'];
+  unseen?: SessionPanelProps['unseen'];
+  onVitals?: SessionPanelProps['onVitals'];
+  /** Rail width in pixels on first render. */
+  defaultRailWidth?: number;
+  /** Start with the file rail collapsed even on a wide viewport. */
+  defaultRailCollapsed?: boolean;
+  /**
+   * The rail moved. Paired with the two defaults so an embedder can persist the
+   * layout — the workspace deliberately does not, because *where* to keep it (a
+   * Memento, localStorage, a workspace file) is the embedder's call, and a
+   * component that picked one would be wrong in the other hosts.
+   */
+  onRailChange?: (rail: {
+    width: number;
+    collapsed: boolean;
+  }) => void;
+  className?: string;
+}
+/**
+ * A VS Code-shaped workspace around a live session: file tree on the left, open
+ * files above, the agent below.
+ *
+ * **Strictly additive.** {@link SessionPanel} is untouched and still the whole
+ * session surface on its own — an embedder picks one or the other, and one that
+ * has its own file tree keeps using the panel.
+ *
+ * Two things here are load-bearing and easy to break:
+ *
+ * 1. **The editor region is absent from the layout when nothing is open**, not
+ *    collapsed to zero height. A zero-height pane leaves a draggable splitter and
+ *    parks the composer at an odd offset; absence is what makes the agent's
+ *    "claims the full column" state actually look like the panel alone.
+ * 2. **`SessionPanel` keeps its position in the tree across that transition.** It
+ *    holds the WebSocket attach and the entire transcript, so moving it between
+ *    parents — or wrapping it conditionally — would remount it and drop the
+ *    session's rendered history on the floor the first time someone opens a file.
+ *    The conditional children before it are `? :` expressions that leave a null in
+ *    their slot, which is exactly what keeps its index stable.
+ */
+declare function SessionWorkspace({
+  client,
+  sessionId,
+  header,
+  transcriptVariant,
+  transcriptDensity,
+  unseen,
+  onVitals,
+  defaultRailWidth,
+  defaultRailCollapsed,
+  onRailChange,
+  className
+}: SessionWorkspaceProps): _$react.JSX.Element;
+//#endregion
+//#region src/components/agent/FileTree.d.ts
+interface FileTreeProps {
+  /** Tree state from `useHostFileTree` — this component holds none of its own. */
+  tree: UseHostFileTreeResult;
+  /** Optional search from `useHostFileSearch`; omit and the box is not offered. */
+  search?: UseHostFileSearchResult;
+  /** Path of the focused file, highlighted in the tree. */
+  activePath?: string;
+  onOpenFile: (path: string) => void;
+  /** Offered as a button in the header when given. */
+  onCollapse?: () => void;
+  style?: CSSProperties;
+  className?: string;
+}
+/**
+ * The workspace's left rail: an expandable tree of the session's project,
+ * with a search box over the same fuzzy route `@file` completion uses.
+ *
+ * Presentational by construction — every piece of state it renders comes from
+ * the hooks in `@workerdeck/react`, and the only thing it owns is the search
+ * query, which is the text in its own input.
+ *
+ * Searching replaces the tree with matches rather than filtering it: the route
+ * answers with paths from all over the project, and threading those back into
+ * tree positions would mean expanding a dozen directories to show six results.
+ */
+declare function FileTree({
+  tree,
+  search,
+  activePath,
+  onOpenFile,
+  onCollapse,
+  style,
+  className
+}: FileTreeProps): _$react.JSX.Element;
+//#endregion
+//#region src/components/agent/EditorTabs.d.ts
+interface EditorTabsProps {
+  files: OpenFile[];
+  activePath?: string;
+  onActivate: (path: string) => void;
+  onClose: (path: string) => void;
+  className?: string;
+}
+/**
+ * The open-file tab strip.
+ *
+ * Hand-rolled rather than built on `@base-ui/react`'s `Tabs`: a VS Code tab
+ * carries a close button, and a `<button>` inside a `<button>` is invalid HTML —
+ * getting the primitive to render something else costs more than the roving
+ * tabindex it would have provided. So that part is here, explicitly, along with
+ * the two affordances that actually make a tab strip feel right: middle-click to
+ * close, and the active tab scrolling itself into view.
+ *
+ * Deliberately state-free. Which files are open, which is focused and what
+ * closing does are all decided by `useOpenFiles`.
+ */
+declare function EditorTabs({
+  files,
+  activePath,
+  onActivate,
+  onClose,
+  className
+}: EditorTabsProps): _$react.JSX.Element;
+//#endregion
+//#region src/components/agent/FileViewer.d.ts
+interface FileViewerProps {
+  file: OpenFile | undefined;
+  /** From `/fs/roots`. False renders the editor read-only rather than letting
+   * someone type into a file this gateway will refuse to write. */
+  canWrite?: boolean;
+  onChange?: (path: string, content: string) => void;
+  onSave?: (path: string) => void;
+  /** Discard this tab's edits — local only, no re-read. */
+  onRevert?: (path: string) => void;
+  /** Take the version on disk, discarding this tab's edits. */
+  onReload?: (path: string) => void;
+  /** Take this tab's version, over whatever is on disk now. */
+  onOverwrite?: (path: string) => void;
+  onDismissConflict?: (path: string) => void;
+  className?: string;
+}
+/**
+ * The focused file: Monaco, plus the states a file can be in that are not
+ * "here is some text".
+ *
+ * No path row — the tab's tooltip carries the path and the size, and a line of
+ * monospace above every file is chrome that never earns its height.
+ */
+declare function FileViewer({
+  file,
+  canWrite,
+  onChange,
+  onSave,
+  onRevert,
+  onReload,
+  onOverwrite,
+  onDismissConflict,
+  className
+}: FileViewerProps): _$react.JSX.Element | null;
+//#endregion
+//#region src/components/agent/CodeEditor.d.ts
+interface CodeEditorProps {
+  /** Absolute path — decides the language and identifies the model. */
+  path: string;
+  /** Text to show. Applied to the model when it differs from what is on screen,
+   * so an external reload lands without fighting the user's cursor. */
+  value: string;
+  onChange?: (value: string) => void;
+  /** Ctrl/Cmd+S. Wired inside Monaco because the editor swallows keydown. */
+  onSave?: () => void;
+  readOnly?: boolean;
+  className?: string;
+}
+/**
+ * Monaco — VS Code's own editor — behind a small React surface.
+ *
+ * Two deliberate choices, both about `@workerdeck/ui` being a **published
+ * library** rather than an app:
+ *
+ * 1. **Loaded on demand.** The `import()` is inside an effect, so Monaco is a
+ *    separate chunk that arrives when someone first opens a file. A dashboard
+ *    that never opens one never pays for it, and Monaco's ~90 language grammars
+ *    are themselves lazy (each `registerLanguage` carries an `import()` loader),
+ *    so opening a `.ts` file fetches the TypeScript grammar and nothing else.
+ * 2. **No `MonacoEnvironment` is configured here, and none is needed.** Workers
+ *    in a library become every embedder's bootstrapping problem, and
+ *    `packages/web` ships prebuilt static files at a domain root, which is
+ *    exactly where hardcoded worker URLs break. The editor is configured so it
+ *    never asks for one: `wordBasedSuggestions` and `quickSuggestions` off,
+ *    no diff editor. A host that wants the worker-backed language services
+ *    (TypeScript IntelliSense, JSON schema validation) sets `MonacoEnvironment`
+ *    itself before the first file is opened — Monaco is a singleton and nothing
+ *    here fights that.
+ *
+ * One model per path, kept across tab switches, so undo history and view state
+ * survive clicking away and back — which is most of what makes tabs feel like
+ * tabs rather than like re-opening a file.
+ */
+declare function CodeEditor({
+  path,
+  value,
+  onChange,
+  onSave,
+  readOnly,
+  className
+}: CodeEditorProps): _$react.JSX.Element;
+//#endregion
+export { CodeEditor, type CodeEditorProps, EditorTabs, type EditorTabsProps, FileTree, type FileTreeProps, FileViewer, type FileViewerProps, SessionWorkspace, type SessionWorkspaceProps };
+//# sourceMappingURL=workspace.d.mts.map