@svelterm/core 0.1.0 → 0.21.0

package/dist/src/framelog.js

@@ -0,0 +1,99 @@
+/**
+ * FrameLog — an append-only log of frames for inline mode. Each frame is
+ * a mounted component; archiving hands its rows to the terminal's
+ * scrollback and frees the component, so a long session's memory tracks
+ * what's live, not the whole history.
+ *
+ * The host element should be the first content on screen (frames release
+ * from the top). To update a frame after append, pass a `$state` object
+ * as its props and mutate it — or use `update()`, which assigns onto that
+ * same object.
+ */
+import { mount, unmount } from 'svelte/renderer';
+import defaultRenderer from './renderer/default.js';
+import { TermNode } from './renderer/node.js';
+const inlineHooksByRoot = new WeakMap();
+/** Called by run() in inline mode so FrameLogs can archive rows. */
+export function registerInlineHooks(root, hooks) {
+    inlineHooksByRoot.set(root, hooks);
+}
+export class FrameLog {
+    host;
+    deps;
+    frames = [];
+    nextId = 1;
+    constructor(host, deps = {
+        mount, unmount, renderer: defaultRenderer,
+    }) {
+        this.host = host;
+        this.deps = deps;
+    }
+    /** Mount a component as a new frame at the bottom of the log. */
+    append(component, props) {
+        const container = new TermNode('element', 'div');
+        container.attributes.set('data-frame', String(this.nextId));
+        this.host.insertBefore(container, null);
+        const app = this.deps.mount(component, {
+            renderer: this.deps.renderer,
+            target: container,
+            props,
+        });
+        const id = this.nextId++;
+        this.frames.push({ id, container, app, props });
+        return id;
+    }
+    /**
+     * Assign new values onto the frame's props object. Reaches the
+     * component only when the props were created with `$state`.
+     */
+    update(id, partial) {
+        const frame = this.frames.find(f => f.id === id);
+        if (!frame)
+            throw new Error(`FrameLog: no live frame ${id}`);
+        Object.assign(frame.props, partial);
+    }
+    /**
+     * Archive every frame up to and including `id`: their rows stay on
+     * the terminal and scroll into history; their components unmount.
+     */
+    archive(id) {
+        const index = this.frames.findIndex(f => f.id === id);
+        if (index < 0)
+            throw new Error(`FrameLog: no live frame ${id}`);
+        const archived = this.frames.slice(0, index + 1);
+        const rows = archived.reduce((sum, frame) => sum + (frame.container.cache.layoutBox?.height ?? 0), 0);
+        this.rootHooks()?.releaseTop(rows);
+        for (const frame of archived)
+            this.dispose(frame);
+        this.frames.splice(0, index + 1);
+    }
+    /** Remove a frame outright — its rows clear and the log reflows. */
+    remove(id) {
+        const index = this.frames.findIndex(f => f.id === id);
+        if (index < 0)
+            throw new Error(`FrameLog: no live frame ${id}`);
+        this.dispose(this.frames[index]);
+        this.frames.splice(index, 1);
+    }
+    /** IDs of the frames still live, in order. */
+    liveFrames() {
+        return this.frames.map(f => f.id);
+    }
+    dispose(frame) {
+        this.deps.unmount(frame.app);
+        this.host.removeChild(frame.container);
+    }
+    rootHooks() {
+        let node = this.host;
+        while (node.parent)
+            node = node.parent;
+        return inlineHooksByRoot.get(node);
+    }
+}
+/**
+ * A FrameLog bound to a host element — from a component, grab the node
+ * with `bind:this` and create the log once on mount.
+ */
+export function createFrameLog(host) {
+    return new FrameLog(host);
+}

package/dist/src/headless.js

@@ -1,3 +1,4 @@
+import { mount as svelteMount, unmount as svelteUnmount } from 'svelte/renderer';
 import { TermNode } from './renderer/index.js';
 import renderer from './renderer/default.js';
 import { CellBuffer } from './render/buffer.js';
@@ -5,6 +6,7 @@ import { paint } from './render/paint.js';
 import { parseCSS } from './css/parser.js';
 import { resolveStyles } from './css/compute.js';
 import { computeLayout } from './layout/engine.js';
+import { DEFAULT_STYLESHEET } from './css/defaults.js';
 /**
  * Render a Svelte component headlessly (no terminal) for testing.
  * Returns the cell buffer, virtual tree, and unmount function.
@@ -13,11 +15,17 @@ export function renderHeadless(AppComponent, options = {}) {
     const width = options.width ?? 80;
     const height = options.height ?? 24;
     const root = new TermNode('element', 'root');
-    const stylesheet = options.css ? parseCSS(options.css) : null;
-    const { unmount } = renderer.render(AppComponent, { target: root, props: options.props ?? {} });
+    const stylesheet = parseCSS(DEFAULT_STYLESHEET + (options.css ?? ''));
+    const app = svelteMount(AppComponent, {
+        renderer,
+        target: root,
+        props: options.props ?? {},
+        context: new Map([[Symbol.for('@svelterm/target'), 'terminal']]),
+    });
+    const unmount = () => void svelteUnmount(app);
     const buffer = new CellBuffer(width, height);
-    const styles = stylesheet ? resolveStyles(root, stylesheet) : undefined;
-    const layout = styles ? computeLayout(root, styles, width, height) : undefined;
+    const styles = resolveStyles(root, stylesheet);
+    const layout = computeLayout(root, styles, width, height);
     paint(root, buffer, styles, layout);
     return { buffer, root, unmount };
 }

package/dist/src/index.d.ts

@@ -1,18 +1,80 @@
 import type { Component, ComponentType, SvelteComponent } from 'svelte';
-export interface MountOptions {
+import { type ColorDepth } from './terminal/capabilities.js';
+import { type TerminalIO } from './terminal/io.js';
+export interface ConsoleEntry {
+    level: 'log' | 'warn' | 'error' | 'info' | 'debug';
+    args: string[];
+    timestamp: number;
+}
+export interface RunOptions {
     fullscreen?: boolean;
     css?: string;
     mouse?: boolean;
     debug?: boolean;
     debugPort?: number;
+    io?: TerminalIO;
+    onConsole?: (entry: ConsoleEntry) => void;
+    /**
+     * Override the terminal's color scheme. When set, OSC11 polling is
+     * skipped and this value is used directly. Useful for embedded
+     * terminals (browser previews) where the OSC channel is meaningless
+     * and the host already knows the scheme.
+     */
+    colorScheme?: 'dark' | 'light';
+    /**
+     * 'fullscreen' (default) uses the alternate screen buffer. 'inline'
+     * renders at the shell cursor in the main buffer: output above the
+     * live area scrolls into real scrollback, the live area sizes to its
+     * content, and all cursor movement is relative. Mouse events map
+     * into the live area via a cursor-position query; clicks on shell
+     * history above it are ignored.
+     */
+    mode?: 'fullscreen' | 'inline';
+    /**
+     * Key combinations that exit the app. Ctrl+C always exits; add
+     * 'ctrl+d' for EOF-style exit. Default: ['ctrl+c'].
+     */
+    exitOn?: Array<'ctrl+c' | 'ctrl+d'>;
+    /**
+     * Override colour depth instead of detecting it (NO_COLOR/COLORTERM/
+     * XTVERSION). Hex colours quantize to the terminal's palette at emit
+     * time; `mono` drops colour output entirely.
+     */
+    colorDepth?: ColorDepth;
+}
+/** @deprecated Use RunOptions */
+export type MountOptions = RunOptions;
+export interface RunHandle {
+    /** Tear down the run — restore stdio, unmount components, stop pollers. */
+    cleanup: () => void;
+    /**
+     * Update the active color scheme on a live run. Triggers a full repaint
+     * so default-colored cells render with the new defaults and CSS @media
+     * (color-scheme: ...) rules re-resolve. No-op if the scheme is unchanged.
+     *
+     * Calling this also stops any background OSC-11 polling — the caller is
+     * declaring they own the scheme, and we don't want the poller racing to
+     * overwrite it 1s later.
+     */
+    setColorScheme: (scheme: 'dark' | 'light') => void;
 }
-export declare function run<Props extends Record<string, any>>(AppComponent: ComponentType<SvelteComponent<Props>> | Component<Props>, options?: MountOptions & ({} extends Props ? {
+/**
+ * Register a component's extracted CSS before run() is called. Bundled
+ * builds (`svelterm build`) and the dev-mode transform append a
+ * registration call to each compiled component so it carries its styles;
+ * run() falls back to the registry when no `css` option is given.
+ */
+export declare function registerComponentCss(css: string): void;
+export declare function run<Props extends Record<string, any>>(AppComponent: ComponentType<SvelteComponent<Props>> | Component<Props>, options?: RunOptions & ({} extends Props ? {
     props?: Props;
 } : {
     props: Props;
-})): () => void;
+})): RunHandle;
 export { TermNode } from './renderer/node.js';
 export { CellBuffer } from './render/buffer.js';
 export { parseCSS } from './css/parser.js';
 export { resolveStyles } from './css/compute.js';
 export { StdinRouter } from './terminal/stdin-router.js';
+export { type TerminalIO, ProcessIO, InProcessIO } from './terminal/io.js';
+export { copyToClipboard, osc52Copy } from './terminal/clipboard.js';
+export { FrameLog, createFrameLog } from './framelog.js';