@pstdio/ui 0.14.0 → 0.16.0

package/dist/components/rich-text/shared/plugins/MermaidPlugin/MermaidNode.d.ts

@@ -19,5 +19,4 @@ export declare class MermaidNode extends DecoratorNode<ReactNode> {
     setCode(code: string): void;
     decorate(): import("react/jsx-runtime").JSX.Element;
 }
-export declare function $createMermaidNode(code?: string): MermaidNode;
 export declare function $isMermaidNode(node: LexicalNode | null | undefined): node is MermaidNode;

package/dist/components/rich-text/utils/inferResourceType.d.ts

@@ -1 +1 @@
-export declare function inferResourceTypeFromMediaType(mediaType: string): "text" | "table" | "image" | "json" | "markdown" | "pdf";
+export declare function inferResourceTypeFromMediaType(mediaType: string): "text" | "table" | "image" | "json" | "pdf" | "markdown";

package/dist/components/sidebar/sidebar.types.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { ResourceContextAction } from '../resource-context-menu';
+import { ResourceContextAction } from '../overlays/resource-context-menu';
 import { TreeListLinkComponent, TreeListNavigateEvent, TreeListSection } from '../tree-list/tree-list.types';
 export interface SidebarProps {
     storageKey: string;

package/dist/components/tab-strip/tab-visibility-filter.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { ResourceContextAction } from '../resource-context-menu';
+import { ResourceContextAction } from '../overlays/resource-context-menu';
 import { VisibilityOverride } from '../tree-list/tree-list-visibility.store';
 export interface TabVisibilityPlacement {
     closable?: boolean;
@@ -13,7 +13,9 @@ export interface TabVisibilityMenuActions {
     onResetAll: () => void;
 }
 interface BuildTabMenuOptions {
-    checkmark: ReactNode;
+    visibleIcon: ReactNode;
+    hiddenIcon: ReactNode;
+    resetIcon?: ReactNode;
 }
-export declare const buildTabVisibilityMenuActions: <T extends TabVisibilityPlacement>(placements: T[], tabOverrides: Record<string, VisibilityOverride>, actions: TabVisibilityMenuActions, getKey: (placement: T) => string, options: BuildTabMenuOptions) => ResourceContextAction[];
+export declare const buildTabVisibilityMenuActions: <T extends TabVisibilityPlacement>(placements: T[], tabOverrides: Record<string, VisibilityOverride>, actions: TabVisibilityMenuActions, getKey: (placement: T) => string, options: BuildTabMenuOptions, getIcon?: (placement: T) => ReactNode) => ResourceContextAction[];
 export {};

package/dist/components/tag-editor/tag-editor-row.d.ts

@@ -1,4 +1,4 @@
-import { IconColorPickerIconOption } from '../icon-color-picker';
+import { IconColorPickerIconOption } from '../primitives/icon-color-picker';
 import { TagEditorAction, TagEditorValue } from './tag-editor.types';
 interface TagEditorRowProps {
     actionOptions?: TagEditorAction[];

package/dist/components/tag-editor/tag-editor.types.d.ts

@@ -1,4 +1,4 @@
-import { IconColorPickerIconOption } from '../icon-color-picker';
+import { IconColorPickerIconOption } from '../primitives/icon-color-picker';
 export interface TagEditorValue {
     id: string;
     name: string;

package/dist/components/terminal/bind-session.d.ts

@@ -0,0 +1,33 @@
+import { TerminalSessionAdapter } from './types';
+/**
+ * Minimal subset of xterm.js that the binding needs. Tests substitute a fake
+ * sink so the wire-up logic can be exercised without a DOM.
+ */
+export interface TerminalSink {
+    write(data: string | Uint8Array): void;
+    onInput(handler: (data: string) => void): () => void;
+    onResize(handler: (size: {
+        cols: number;
+        rows: number;
+    }) => void): () => void;
+}
+export interface BindSessionOptions {
+    /** Forwarded to the session when the user types in the sink. */
+    onInput?: (data: string) => void;
+    /** Called once the session exits; useful for surfacing status. */
+    onExit?: (exit: {
+        code: number | null;
+        signal: string | null;
+    }) => void;
+    /** Called on transport errors. */
+    onError?: (error: {
+        message: string;
+    }) => void;
+}
+/**
+ * Wires a {@link TerminalSink} (typically xterm.js) to a
+ * {@link TerminalSessionAdapter}. Returns a disposer that detaches every
+ * subscription it created. The session itself is *not* killed — owning the
+ * session lifecycle is the caller's responsibility.
+ */
+export declare const bindSessionToSink: (sink: TerminalSink, session: TerminalSessionAdapter, options?: BindSessionOptions) => () => void;

package/dist/components/terminal/index.d.ts

@@ -0,0 +1,6 @@
+export { type BindSessionOptions, bindSessionToSink, type TerminalSink } from './bind-session';
+export { createScriptedTerminalBridge, type ScriptedBridgeOptions, type ScriptedTerminalStep, } from './scripted-bridge';
+export { Terminal, type TerminalProps } from './terminal';
+export { darkTerminalTheme, lightTerminalTheme, resolveTerminalTheme, type TerminalThemeName, terminalThemes, } from './terminal-theme';
+export type { TerminalBridge, TerminalSessionAdapter, TerminalSessionError, TerminalSessionExit, TerminalSessionRequest, } from './types';
+export { type TerminalSessionStatus, type UseTerminalSessionOptions, type UseTerminalSessionResult, useTerminalSession, } from './use-terminal-session';

package/dist/components/terminal/scripted-bridge.d.ts

@@ -0,0 +1,35 @@
+import { TerminalBridge } from './types';
+export interface ScriptedTerminalStep {
+    /** Bytes the host pushes back to the renderer (utf-8 string is encoded for you). */
+    data?: string | Uint8Array;
+    /** Milliseconds to wait before delivering this step. */
+    delayMs?: number;
+    /** Marks the session as exited after this step. */
+    exit?: {
+        code: number | null;
+        signal?: string | null;
+    };
+    /** Delivers a transport error after this step. */
+    error?: string;
+}
+export interface ScriptedBridgeOptions {
+    /** Initial script delivered after the first data subscriber attaches. */
+    initial?: ScriptedTerminalStep[];
+    /**
+     * Responds to user input. Return additional steps to play, or `undefined`
+     * to ignore. Defaults to echoing the input followed by a newline.
+     */
+    onInput?: (input: string) => ScriptedTerminalStep[] | undefined;
+    /** Called whenever the renderer requests a resize. */
+    onResize?: (size: {
+        cols: number;
+        rows: number;
+    }) => void;
+    /** Called once when the renderer kills the session. */
+    onKill?: (signal?: string) => void;
+}
+/**
+ * Deterministic in-memory bridge. Used by stories and tests to exercise the
+ * terminal UI without a real PTY supervisor.
+ */
+export declare const createScriptedTerminalBridge: (options?: ScriptedBridgeOptions) => TerminalBridge;

package/dist/components/terminal/terminal-contract.d.ts

@@ -0,0 +1,22 @@
+export interface TerminalSessionRequest {
+    /** Command + args to run; defaults to the user's login shell when omitted. */
+    command?: string[];
+    /** Working directory; falls back to the extension's workspace root. */
+    cwd?: string;
+    /** Extra env vars merged over the inherited environment. */
+    env?: Record<string, string>;
+    /** Initial column count; the renderer can resize later. */
+    cols: number;
+    /** Initial row count; the renderer can resize later. */
+    rows: number;
+}
+export type TerminalHostEvent = {
+    sessionId: string;
+    kind: "data";
+    chunk: Uint8Array;
+} | {
+    sessionId: string;
+    kind: "exit";
+    code: number | null;
+    signal: string | null;
+};

package/dist/components/terminal/terminal-theme.d.ts

@@ -0,0 +1,12 @@
+import { ITheme } from '@xterm/xterm';
+/**
+ * xterm theme presets aligned with the workbench `bg.inverted` / `fg.inverted`
+ * pairings so the terminal blends with the surrounding chrome without the
+ * consuming extension touching xterm directly. Consumers can still pass any
+ * `ITheme` they like via the `theme` prop.
+ */
+export type TerminalThemeName = "light" | "dark";
+export declare const lightTerminalTheme: ITheme;
+export declare const darkTerminalTheme: ITheme;
+export declare const terminalThemes: Record<TerminalThemeName, ITheme>;
+export declare const resolveTerminalTheme: (theme: TerminalThemeName | ITheme | undefined) => ITheme;

package/dist/components/terminal/terminal.d.ts

@@ -0,0 +1,45 @@
+import { ITheme, Terminal as Xterm } from '@xterm/xterm';
+import { TerminalSink } from './bind-session';
+import { TerminalThemeName } from './terminal-theme';
+import { TerminalBridge, TerminalSessionAdapter, TerminalSessionRequest } from './types';
+export declare const createInitialTerminalSessionRequest: (request?: Partial<TerminalSessionRequest>) => TerminalSessionRequest;
+export declare const resizeSessionToTerminalGeometry: (terminal: Pick<Xterm, "cols" | "rows">, session: Pick<TerminalSessionAdapter, "resize">) => void;
+export declare const bindTerminalSession: (terminal: Pick<Xterm, "cols" | "rows">, sink: TerminalSink, session: TerminalSessionAdapter, options: Pick<TerminalProps, "onSessionOpen" | "onSessionExit">) => () => void;
+export interface TerminalSessionCallbackRefs {
+    onSessionOpen: React.RefObject<TerminalProps["onSessionOpen"]>;
+    onSessionExit: React.RefObject<TerminalProps["onSessionExit"]>;
+}
+export declare const bindTerminalSessionWithCallbackRefs: (terminal: Pick<Xterm, "cols" | "rows">, sink: TerminalSink, session: TerminalSessionAdapter, callbackRefs: TerminalSessionCallbackRefs) => () => void;
+export interface TerminalProps {
+    /** Bridge adapter the component opens its session through. */
+    bridge: TerminalBridge;
+    /**
+     * Optional initial session request overrides. `cols`/`rows` default to
+     * 80x24; container resizes are forwarded after the session opens.
+     */
+    request?: Partial<TerminalSessionRequest>;
+    /** Theme preset name or full xterm theme. */
+    theme?: TerminalThemeName | ITheme;
+    /** Monospace font family. */
+    fontFamily?: string;
+    fontSize?: number;
+    /** Whether to kill the session when the component unmounts. Defaults to true. */
+    killOnUnmount?: boolean;
+    /** Forwarded to the container element. */
+    className?: string;
+    style?: React.CSSProperties;
+    /** Called once the session is open; useful for imperative refs. */
+    onSessionOpen?: (sessionId: string) => void;
+    /** Called once the session exits. */
+    onSessionExit?: (exit: {
+        code: number | null;
+        signal: string | null;
+    }) => void;
+}
+/**
+ * High-level terminal component. Mounts xterm.js inside a `<div>` and binds it
+ * to the session opened from `bridge.openSession(...)`. Resize is driven by
+ * `ResizeObserver` so the terminal fills its container and the host PTY
+ * geometry stays in sync.
+ */
+export declare const Terminal: (props: TerminalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/terminal/types.d.ts

@@ -0,0 +1,35 @@
+import { TerminalHostEvent, TerminalSessionRequest } from './terminal-contract';
+export type { TerminalSessionRequest } from './terminal-contract';
+/**
+ * Renderer-side projection of a single terminal session over the
+ * `terminal.session` bridge.
+ *
+ * The host-side `TerminalSessionHandle` exposes a single-consumer async
+ * iterable; that contract is impractical inside React, so the renderer side
+ * uses observable subscriptions instead. Implementations (real bridge,
+ * scripted stub, etc.) are responsible for translating their own transport
+ * into these callbacks.
+ */
+export interface TerminalSessionAdapter {
+    readonly id: string;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    kill(signal?: string): Promise<void> | void;
+    onData(handler: (chunk: Uint8Array) => void): () => void;
+    onExit(handler: (exit: TerminalSessionExit) => void): () => void;
+    onError(handler: (error: TerminalSessionError) => void): () => void;
+}
+export type TerminalSessionExit = Omit<Extract<TerminalHostEvent, {
+    kind: "exit";
+}>, "kind" | "sessionId">;
+export interface TerminalSessionError {
+    message: string;
+}
+/**
+ * Renderer-side projection of the `terminal.session` capability. A bridge
+ * adapter typically wraps the webview transport, but stubs that drive
+ * scripted output (storybook, tests) implement the same shape.
+ */
+export interface TerminalBridge {
+    openSession(request: TerminalSessionRequest): Promise<TerminalSessionAdapter>;
+}

package/dist/components/terminal/use-terminal-session.d.ts

@@ -0,0 +1,21 @@
+import { TerminalBridge, TerminalSessionAdapter, TerminalSessionError, TerminalSessionExit, TerminalSessionRequest } from './types';
+export type TerminalSessionStatus = "idle" | "opening" | "open" | "exited" | "error";
+export interface UseTerminalSessionResult {
+    session: TerminalSessionAdapter | null;
+    status: TerminalSessionStatus;
+    exit: TerminalSessionExit | null;
+    error: TerminalSessionError | null;
+}
+export interface UseTerminalSessionOptions {
+    bridge: TerminalBridge | null;
+    request: TerminalSessionRequest;
+    /** Set to false to keep the session alive when the hook unmounts. */
+    killOnUnmount?: boolean;
+}
+export declare const createTerminalSessionRequestKey: (request: TerminalSessionRequest) => string;
+/**
+ * Opens a terminal session via the provided bridge and surfaces its lifecycle
+ * for the renderer. The session is killed on unmount unless explicitly opted
+ * out; switching bridges or request contents triggers a fresh open.
+ */
+export declare const useTerminalSession: ({ bridge, request, killOnUnmount }: UseTerminalSessionOptions) => UseTerminalSessionResult;

package/dist/components/tree-list/tree-list-order-filter.d.ts

@@ -1,3 +1,2 @@
-import { TreeListNode, TreeListSection } from './tree-list.types';
+import { TreeListSection } from './tree-list.types';
 export declare const applyTreeListOrder: (sections: TreeListSection[], sectionOrder: string[], nodeOrderBySection: Record<string, string[]>) => TreeListSection[];
-export declare const reorderNodesById: (nodes: TreeListNode[], order: string[]) => TreeListNode[];

package/dist/components/tree-list/tree-list-visibility-filter.d.ts

@@ -1,8 +1,9 @@
 import { ReactNode } from 'react';
-import { ResourceContextAction } from '../resource-context-menu';
-import { TreeListSection } from './tree-list.types';
+import { ResourceContextAction } from '../overlays/resource-context-menu';
+import { TreeListNode, TreeListSection } from './tree-list.types';
 import { VisibilityOverride } from './tree-list-visibility.store';
 export declare const resolveVisibility: (override: VisibilityOverride | undefined, hiddenByDefault: boolean | undefined) => VisibilityOverride;
+export declare const filterVisibleNodes: (nodes: TreeListNode[], nodeOverrides: Record<string, VisibilityOverride>) => TreeListNode[];
 export declare const filterVisibleSections: (sections: TreeListSection[], sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>) => TreeListSection[];
 export interface TreeVisibilityMenuActions {
     onToggleSection: (id: string, hiddenByDefault: boolean) => void;
@@ -11,7 +12,14 @@ export interface TreeVisibilityMenuActions {
     onResetOrder?: () => void;
 }
 interface BuildMenuOptions {
-    checkmark: ReactNode;
+    visibleIcon: ReactNode;
+    hiddenIcon: ReactNode;
+    resetIcon?: ReactNode;
 }
-export declare const buildTreeVisibilityMenuActions: (sections: TreeListSection[], sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>, actions: TreeVisibilityMenuActions, options: BuildMenuOptions) => ResourceContextAction[];
+export interface TreeVisibilityMenuItems {
+    headerNodes?: TreeListNode[];
+    sections: TreeListSection[];
+    footerNodes?: TreeListNode[];
+}
+export declare const buildTreeVisibilityMenuActions: (items: TreeVisibilityMenuItems, sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>, actions: TreeVisibilityMenuActions, options: BuildMenuOptions) => ResourceContextAction[];
 export {};

package/dist/components/tree-list/tree-list.d.ts

@@ -1,6 +1,6 @@
 import { StackProps } from '@chakra-ui/react';
 import { MouseEvent as ReactMouseEvent, RefObject } from 'react';
-import { ResourceContextAction } from '../resource-context-menu';
+import { ResourceContextAction } from '../overlays/resource-context-menu';
 import { TreeListLinkComponent, TreeListNavigateEvent, TreeListSection } from './tree-list.types';
 export { buildVirtualRows } from './tree-list-model';
 type TreeListRowVariant = "compact" | "tree";

package/dist/components/tree-list/tree-list.types.d.ts

@@ -1,15 +1,18 @@
 import { ComponentType, ReactNode } from 'react';
-import { ListRowAction, ListRowActionContext, ListRowActionMenuItem, ListRowItem, ListRowNavigationIntent } from '../list-row/list-row.types';
+import { ListRowAction, ListRowActionContext, ListRowActionMenuItem, ListRowItem, ListRowNavigationIntent, ListRowVariant } from '../list-row/list-row.types';
 export type TreeListNavigationIntent = ListRowNavigationIntent;
 export type TreeListActionContext = ListRowActionContext;
 export type TreeListActionMenuItem = ListRowActionMenuItem;
 export type TreeListAction = ListRowAction;
+export type TreeListNodeRowVariant = Extract<ListRowVariant, "empty-state">;
 /** Tree node data rendered by `TreeList`; extends the row API used by `ListRow`. */
 export type TreeListNode = ListRowItem & {
     id: string;
     children?: TreeListNode[];
+    /** Per-node visual row variant. Used for non-interactive placeholder rows. */
+    rowVariant?: TreeListNodeRowVariant;
     hiddenByDefault?: boolean;
-    /** When false, the node cannot be hidden from a tree-customization menu (rendered as a disabled, checked row). */
+    /** Opt in to the tree-customization (hide/show) menu. Items are non-hideable unless this is true. */
     canHide?: boolean;
 };
 /** Top-level tree section with optional header, actions, empty state, and child nodes. */
@@ -21,6 +24,8 @@ export interface TreeListSection {
     emptyState?: ReactNode;
     nodes: TreeListNode[];
     hiddenByDefault?: boolean;
+    /** Opt in to the tree-customization (hide/show) menu. Sections are non-hideable unless this is true. */
+    canHide?: boolean;
 }
 /** Navigation payload emitted when a navigable tree node is activated. */
 export interface TreeListNavigateEvent {