dsh-coding-sidebar 1.0.3 → 1.0.4

package/lib/types/client/MarkdownHtml.d.ts

@@ -1,32 +0,0 @@
-import { type ReactNode } from 'react';
-import { type AnalyzedMarkdownHtml } from './markdown-html.ts';
-import { type MermaidMarkdownProps } from './mermaid-blocks.ts';
-import type { SessionScope } from './api.ts';
-/** The chunk-resident markdown renderer (mermaid lazy chunk), shared with the
- *  legacy no-HTML preview path in TextEditor. */
-export declare const LazyMermaidMarkdown: (props: MermaidMarkdownProps) => ReactNode;
-/** Everything the sanitizers need to resolve local media + scope the route. */
-export interface MarkdownHtmlMedia {
-    scope: SessionScope;
-    path: string;
-    origin: string;
-}
-interface MarkdownDocumentProps {
-    info: AnalyzedMarkdownHtml;
-    media: MarkdownHtmlMedia;
-    codeLabels: {
-        copyLabel: string;
-        copiedLabel: string;
-    };
-}
-/**
- * The split-document renderer: markdown runs render through MarkdownSegment,
- * HTML runs render as sanitized leaves, and unclosed block elements lower the
- * following runs into themselves until their close part pops the frame (the
- * renderer's frame stack persists across segments). Stray closes at the top
- * level render nothing (the sanitizer/parser would drop them anyway), and
- * frames still open at the end of the document are closed like a browser
- * parser would. Sanitization runs once per prepared change, in a memo.
- */
-export declare function MarkdownDocument({ info, media, codeLabels }: MarkdownDocumentProps): ReactNode;
-export {};

package/lib/types/client/PdfView.d.ts

@@ -1,6 +0,0 @@
-import { type SessionScope } from './api.ts';
-export declare function PdfView(props: {
-    scope: SessionScope;
-    path: string;
-    title: string;
-}): import("react").JSX.Element;

package/lib/types/client/builtins/viewers.d.ts

@@ -1,3 +0,0 @@
-import type { FileViewerDescriptor } from '../service.ts';
-/** The 6 built-in file viewer descriptors. */
-export declare function builtinViewers(): readonly FileViewerDescriptor[];

package/lib/types/client/chunks/mermaid.d.ts

@@ -1,10 +0,0 @@
-/**
- * Lazy chunk entry: the mermaid diagram renderer for the markdown preview
- * (mermaid + its d3/dagre/cytoscape graph deps). Built as
- * lib/client-mermaid.js and registered under the `mermaid` global chunk
- * slot — fetched only when a previewed markdown file contains a mermaid
- * fence (see chunk-loader.ts and the mermaid markdown preview design doc).
- * Never import this module from the core bundle: it pulls mermaid into the
- * startup path.
- */
-export { MermaidMarkdown } from '../mermaid.tsx';

package/lib/types/client/editor-load.d.ts

@@ -1,66 +0,0 @@
-/**
- * Pure editor-load planning: the decision logic the editor host needs to
- * turn a matched file viewer + a host fs.read result into a render action.
- * Kept dependency-free (no React, no fetch) so the strategy dispatch is
- * unit-testable and the wire contract (head bytes, binary flag) is pinned.
- *
- * The host flow this module drives:
- *   1. `matchFileViewer(path)` picks a viewer by extension/priority.
- *   2. `planFirstMatch` dispatches its fetchStrategy.
- *   3. An fsRead viewer fetches through the host; `planFsReadOutcome`
- *      decides what to do with the result — including the head-based
- *      re-match that lets a `detect` viewer claim a binary the extension
- *      match could not see (the builtin NUL probe on `binary-download`).
- */
-import type { FileViewerDescriptor } from './service.ts';
-/** One host fs.read result (mirror of the wire; `head` present when binary). */
-export interface FsReadOutcome {
-    binary: boolean;
-    content: string;
-    truncated: boolean;
-    /** base64 of the first bytes (present on binary reads; sniffing material). */
-    head?: string;
-}
-/** What the editor host should do next. */
-export type EditorLoadAction = 
-/** No renderer: show the download UI. */
-{
-    kind: 'binary';
-}
-/** Render `viewer`'s component with the carried payload. */
- | {
-    kind: 'render';
-    viewer: FileViewerDescriptor;
-    content?: string;
-    truncated?: boolean;
-    mediaUrl?: string;
-    customData?: unknown;
-}
-/** Fetch the file through the host (fsRead strategy). */
- | {
-    kind: 'fetchFsRead';
-    viewer: FileViewerDescriptor;
-}
-/** Call the viewer's load() and render with its return value. */
- | {
-    kind: 'customLoad';
-    viewer: FileViewerDescriptor;
-};
-/** Decode the host's base64 head bytes into the sniffing buffer. */
-export declare function decodeHead(headBase64: string): Uint8Array;
-/**
- * Dispatch one matched viewer's fetchStrategy. A missing viewer or a
- * `binary-download` strategy both mean "no client-side renderer" → the
- * download UI. `mediaUrlOf` builds the media URL for `mediaUrl`/`none`
- * strategies (pure, but scope-bound — injected by the host).
- */
-export declare function planFirstMatch(viewer: FileViewerDescriptor | undefined, mediaUrlOf: () => string): EditorLoadAction;
-/**
- * Decide what an fsRead result means for the editor.
- * - Text: the first match stands (content is valid for any fsRead viewer).
- * - Binary: the host head bytes enable a re-match — a `detect` viewer (e.g.
- *   a plugin sniffing a binary format) may claim the file. `custom` viewers
- *   load their own bytes; `mediaUrl`/`none` viewers render the media route;
- *   an fsRead viewer or nothing cannot render binary → download UI.
- */
-export declare function planFsReadOutcome(viewer: FileViewerDescriptor, result: FsReadOutcome, rematch: (head: Uint8Array) => FileViewerDescriptor | undefined, mediaUrlOf: () => string): EditorLoadAction;

package/lib/types/client/image-types.d.ts

@@ -1,3 +0,0 @@
-/** Image extension dispatch, separate from React for unit testing. */
-export declare const IMAGE_EXTENSIONS: readonly string[];
-export declare function isImageExt(ext: string): boolean;

package/lib/types/client/markdown-html.d.ts

@@ -1,96 +0,0 @@
-/**
- * Raw-HTML block detection for the markdown preview. The shared `MarkdownText`
- * renders raw HTML as literal text (a chat-security stance), so a GitHub-style
- * README (`<div align="center">` badge walls, `<details>` collapsibles with
- * markdown inside, table cells full of inline tags) previews as source soup.
- * This module's pure splitter lifts those HTML runs OUT of the markdown stream
- * before rendering: markdown runs keep flowing through `MarkdownText` (shiki /
- * KaTeX / GFM intact, mermaid chunk path unchanged) while HTML runs render as
- * sanitized DOM (see markdown-html.tsx).
- *
- * Splitting follows CommonMark's shape closely enough for real-world READMEs:
- * a line outside code fences that starts with a block-level tag (type-6 list
- * below) or `<!--` opens an HTML run that extends to the next blank line
- * (comments end at the line containing `-->`). Inline-only tags (`<b>`, `<br>`,
- * `<a>`…) never open a run — they stay in the markdown stream and are handled
- * by the inline pass instead. Unclosed block tags (`<details>` … markdown …
- * `</details>`) are surfaced by {@link analyzeHtmlSegment} as ordered parts so
- * the renderer can nest the in-between markdown inside the open element, the
- * way GitHub's linear HTML output nests.
- */
-/** A run of raw HTML lines lifted out of the markdown stream. */
-export interface HtmlSegment {
-    kind: 'html';
-    text: string;
-}
-/** A run of markdown source (may contain non-mermaid fences, inline HTML…). */
-export interface MarkdownHtmlSegment {
-    kind: 'markdown';
-    text: string;
-}
-export type MdHtmlSegment = MarkdownHtmlSegment | HtmlSegment;
-/** The doc-wide analysis the preview consumes (all pure, unit-tested here). */
-export interface AnalyzedMarkdownHtml {
-    /** The document split into markdown / html runs (empty input → []). */
-    segments: MdHtmlSegment[];
-    /** True when at least one html run was lifted out. */
-    hasBlockHtml: boolean;
-    /** True when the source contains any tag-like text (block OR inline). */
-    hasInlineHtml: boolean;
-    /** Every reference definition found in the markdown runs (`[label]: dest`
-     *  lines), joined — appended to each markdown run so `[text][id]` keeps
-     *  resolving across the lifted HTML runs (first-match wins makes the
-     *  appended copy inert inside runs that already define it). */
-    referenceDefinitions: string;
-}
-/**
- * CommonMark HTML-block type-6 tag names (block-level elements), lowercased.
- * A line starting with one of these (open or close) outside a fence begins an
- * HTML run. `<summary>` is CommonMark-inline but intentionally included: it is
- * the idiomatic first child of a `<details>` run in GitHub-flavored READMEs.
- */
-export declare const HTML_BLOCK_TAGS: ReadonlySet<string>;
-/** One structural piece of a lifted HTML run, in document order. */
-export type HtmlPart = {
-    kind: 'html';
-    html: string;
-} | {
-    kind: 'open';
-    tag: string;
-    attrs: string;
-} | {
-    kind: 'close';
-    tag: string;
-};
-/** The run's structure relative to the surrounding document nesting. */
-export interface HtmlSegmentShape {
-    parts: HtmlPart[];
-}
-/**
- * Reduce a lifted HTML run to ordered parts: balanced spans become `html`
- * leaves, unclosed open tags become `open` (a wrapper the renderer lowers
- * following markdown runs into), unmatched closes become `close` (pops one
- * wrapper level). A mismatched close pops through the matching open — the
- * HTML parser's implicit-close behavior. Runs with no structural tags reduce
- * to a single `html` part.
- */
-export declare function analyzeHtmlSegment(source: string): HtmlSegmentShape;
-/**
- * Split markdown source into markdown / html runs (fence-aware: an HTML-looking
- * line inside any fenced code block is content, not a run start). Blank lines
- * terminate HTML runs and are dropped between segments (they carry no markdown
- * semantics the preview needs); everything else stays byte-identical.
- */
-export declare function splitHtmlBlocks(text: string): MdHtmlSegment[];
-/**
- * Collect the reference definitions of every markdown run (HTML runs cannot
- * define them), in document order, newline-joined for appending.
- */
-export declare function collectReferenceDefinitions(segments: readonly MdHtmlSegment[]): string;
-/**
- * The whole-document gate + split the preview consumes. `hasInlineHtml` is a
- * cheap source-level regex (code-fence content may false-positive; the inline
- * pass skips rendered code blocks anyway, so a false positive only costs the
- * enhanced render path, never a behavior change).
- */
-export declare function analyzeMarkdownHtml(text: string): AnalyzedMarkdownHtml;

package/lib/types/client/markdown-images.d.ts

@@ -1,45 +0,0 @@
-/**
- * Markdown-preview local-image resolution. The shared `MarkdownText` (from
- * @deepseek-ai/dsh-client-ui-primitives) only renders absolute http(s) image
- * URLs — relative links are disabled for chat security — so a local image in
- * a previewed `.md` (`![alt](./img.png)`, an absolute `/cwd/img.png`, or a
- * reference definition) would otherwise fall back to its alt text. This
- * dependency-free helper rewrites those destinations into absolute
- * `/sidebar/file` media URLs (prefixed with the GUI's own origin) so
- * `MarkdownText` accepts them; the host media route then serves the bytes,
- * still restricted to files under the session cwd.
- */
-import type { SessionScope } from './api.ts';
-/**
- * Rewrite markdown image destinations that point at local files into
- * absolute `/sidebar/file` media URLs. Relative destinations resolve against
- * the opened file's directory (normalizing `.`/`..` segments); absolute
- * local paths pass through. Remote (http/https/data/mailto) and `#`-anchor
- * destinations are left untouched for `MarkdownText`. Reference-style images
- * (`![x][id]` + `[id]: url`) are covered by rewriting their definition lines.
- *
- * Code spans (`` `...` ``) and fenced code blocks (``` ```...``` ```) are
- * masked before rewriting so documentation that demonstrates `![alt](./img.png)`
- * is not mutated into a `/sidebar/file` URL. Reference definitions are only
- * rewritten when their label is actually referenced by an image (collapsed
- * `[![][id]]`, full `![alt][id]`, or shortcut `![]` referencing the next
- * definition) — a plain link `[text][id]` must not have its destination
- * redirected to the media route.
- * @param text - The raw markdown source (inline + reference images).
- * @param scope - The session scope (sessionId + cwd) for the media route.
- * @param filePath - The absolute path of the opened `.md` file.
- * @param origin - The GUI's own origin (`window.location.origin`); injected
- * so the core rewrite stays pure and unit-testable.
- * @returns The markdown with local image destinations rewritten in place.
- */
-/**
- * Resolve one media destination against the session's media route: local
- * (relative or absolute) paths become absolute `/sidebar/file` URLs (prefixed
- * with the GUI's own origin so the shared MarkdownText http(s) allowlist
- * accepts them), while remote URLs, `#`-anchors and empty destinations are
- * returned untouched. Shared by the markdown image rewriter below and by the
- * preview's raw-HTML sanitizer (`markdown-html.tsx`, which meets the same
- * allowlist when rendering `<img src="./x.png">` inside HTML blocks).
- */
-export declare function resolveLocalMediaDest(dest: string, scope: SessionScope, filePath: string, origin: string): string;
-export declare function rewriteLocalImageUrls(text: string, scope: SessionScope, filePath: string, origin: string): string;

package/lib/types/client/md-toc.d.ts

@@ -1,4 +0,0 @@
-import type { ReactNode } from 'react';
-/** Fewer headings than this and the button stays hidden (no outline value). */
-export declare const TOC_MIN_HEADINGS = 3;
-export declare function MdToc(): ReactNode;

package/lib/types/client/mermaid-blocks.d.ts

@@ -1,47 +0,0 @@
-/**
- * Markdown/mermaid fence detection for the markdown preview. The preview
- * renders the WHOLE document through one DSH `MarkdownText` pass (so
- * cross-fence semantics — reference-style links, footnotes, list
- * continuity — stay intact) and the mermaid lazy chunk then swaps the
- * rendered `language-mermaid` code blocks for diagrams. This module's pure
- * splitter exists to detect whether the source contains a mermaid fence at
- * all, so the mermaid chunk is only fetched when needed (unit-tested in
- * tests/mermaid-blocks.spec.ts).
- */
-/** One fenced mermaid diagram lifted out of the markdown source. */
-export interface MermaidBlock {
-    kind: 'mermaid';
-    /** The raw diagram source between the fences (info string stripped). */
-    code: string;
-}
-/** A span of plain markdown source (may itself contain non-mermaid fences). */
-export interface MarkdownBlock {
-    kind: 'markdown';
-    text: string;
-}
-export type MdBlock = MarkdownBlock | MermaidBlock;
-/** Props of the chunk-resident `MermaidMarkdown` component (shared contract). */
-export interface MermaidMarkdownProps {
-    /** The full markdown source (rendered in a single MarkdownText pass). */
-    text: string;
-    codeLabels: {
-        copyLabel: string;
-        copiedLabel: string;
-    };
-}
-/** CommonMark opening fence: 0-3 spaces indent + a run of 3+ backticks or tildes. */
-export declare const OPEN_FENCE_RE: RegExp;
-/** A closing-fence line: 0-3 spaces indent + 3+ backticks/tildes + trailing spaces only. */
-export declare const CLOSE_FENCE_RE: RegExp;
-/** Parse the info string from the line tail after the fence run; null when invalid. */
-export declare function fenceInfo(rest: string, fence: string): string | null;
-/**
- * Split markdown source into md/mermaid blocks for detection: only fences
- * whose info string names mermaid are lifted; every other line stays in the
- * markdown stream untouched. CommonMark fence rules are honored — opening
- * fences of 3+ backticks OR tildes, and a closing fence must use the same
- * character with at least as many characters as the opening fence. An
- * unterminated mermaid fence swallows the rest of the file (the same
- * recovery CommonMark applies to open fences).
- */
-export declare function splitMermaidBlocks(text: string): MdBlock[];

package/lib/types/client/mermaid-sanitize.d.ts

@@ -1,2 +0,0 @@
-/** A parse failure keeps nothing of the input: the caller shows the error. */
-export declare function sanitizeSvg(svg: string): string;

package/lib/types/client/mermaid.d.ts

@@ -1,12 +0,0 @@
-import type { MermaidMarkdownProps } from './mermaid-blocks.ts';
-/**
- * The chunk-resident markdown preview renderer: ONE MarkdownText pass over
- * the full source (cross-fence reference/footnote/list semantics intact),
- * then every rendered `language-mermaid` code block is swapped for a
- * `MermaidDiagram`. The `.md-code-block` host stays in the React tree —
- * only its children are replaced — so reconciliation never loses the host;
- * a block that stops being a mermaid fence gets its original children back.
- * Only mounted when the source contains at least one mermaid fence (see
- * TextEditor.tsx).
- */
-export declare function MermaidMarkdown({ text, codeLabels }: MermaidMarkdownProps): React.ReactNode;

package/lib/types/client/pdf-types.d.ts

@@ -1,2 +0,0 @@
-/** Pure PDF extension dispatch, separate from React for unit testing. */
-export declare function isPdfExt(ext: string): boolean;

package/lib/types/client/plugins-viewers.d.ts

@@ -1,3 +0,0 @@
-import type { PluginEntry } from './plugins-shared.ts';
-/** File-previewer plugins (alphabetical order). */
-export declare const builtinViewerPlugins: readonly PluginEntry[];

package/lib/types/html-route.d.ts

@@ -1,59 +0,0 @@
-/**
- * Pure URL vocabulary of the /sidebar/html route (HTML previewer).
- *
- * Why path-encoded parameters instead of a query string: the previewed
- * page resolves its relative assets (./style.css, img/x.png) against the
- * document URL, and the WHATWG URL algorithm DROPS the query of a
- * path-relative reference — `/sidebar/html?a=1&path=/a/b/` + `./style.css`
- * would lose the session scope and the route would reject the asset.
- * Encoding everything into the URL path keeps relative resolution inside
- * the same route with every request self-contained:
- *
- *   /sidebar/html/<sessionId>/<absolute-path segments, encodeURIComponent'd>
- *   /sidebar/html/S/Users/me/proj/index.html
- *     + ./style.css → /sidebar/html/S/Users/me/proj/style.css
- *   Windows: C:\Users\me\a.html → /sidebar/html/S/C%3A/Users/me/a.html
- *   UNC (\\server\share\... or //server/share/...):
- *     → /sidebar/html/S//server/share/proj/a.html  ('//' right after the
- *       sessionId marks the UNC prefix; the WHATWG URL keeps '//' intact so
- *       relative assets still resolve inside the same route)
- *
- * The decoder rebuilds the marker as a forward-slash `//server/share/...`
- * path. That form is intentionally platform-neutral: `node:path` resolves it
- * to `\\server\share\...` on win32 and `/server/share/...` on POSIX, so the
- * host's existing requireAbsolute + isWithin fence needs no platform signal
- * (a leading `//` is a legal POSIX absolute path, so no data is lost on
- * either platform).
- *
- * This module is intentionally dependency-free (no node imports, no wire
- * helpers) so the client bundle can import `encodeHtmlUrl` without tripping
- * the build-time purity gate; the host converts decode failures into
- * SidebarError responses at the route boundary.
- */
-/** One decoded route reference. */
-export interface HtmlRouteRef {
-    sessionId: string;
-    /** Absolute file path (leading slash; Windows drives keep their colon). */
-    path: string;
-}
-/** Decode outcome: the reference, or a client-error description. */
-export type HtmlDecodeResult = {
-    ok: true;
-    ref: HtmlRouteRef;
-} | {
-    ok: false;
-    status: 400 | 404;
-    message: string;
-};
-/** The route prefix both encoders/decoders agree on. */
-export declare const HTML_ROUTE_PREFIX = "/sidebar/html/";
-/** Build the route URL for one absolute file path (client + tests). */
-export declare function encodeHtmlUrl(sessionId: string, path: string): string;
-/**
- * Decode a route pathname into the session + absolute file path. Rejects
- * a wrong prefix (404), an empty path, malformed percent encoding, and a
- * missing sessionId or file path (400). The caller still must bound the
- * decoded path with the workspace real-path guard — a decoded `..`
- * segment resolves outside the cwd and is refused there.
- */
-export declare function decodeHtmlUrl(pathname: string): HtmlDecodeResult;