@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/vue/components/list/scroll-state.d.ts

@@ -0,0 +1,25 @@
+export type ScrollTopChange = Readonly<{
+    changed: boolean;
+    dirty: boolean;
+    top: number;
+}>;
+export type ActiveChange = Readonly<{
+    changedActive: boolean;
+    changedScroll: boolean;
+    dirty: boolean;
+    next: number;
+}>;
+export type SyncModelResult = Readonly<{
+    canceledPendingWheel: boolean;
+    reattached: boolean;
+    changedActive: boolean;
+    changedScroll: boolean;
+    dirty: boolean;
+}>;
+export declare function getWheelScrollInput(e: {
+    deltaY?: number;
+    deltaMode?: number;
+}): {
+    deltaY: number;
+    mode: "auto" | "line" | "pixel";
+};

package/dist/vue/components/list/selection-state.d.ts

@@ -0,0 +1,6 @@
+import type { ListVisibleRange } from "./list-geometry.js";
+export declare function normalizeListIndex(value: unknown, itemsLength: number): number;
+export declare function isActiveVisible(active: number, range: ListVisibleRange): boolean;
+export declare function anchorActiveToViewport(active: number, itemsLength: number, range: ListVisibleRange, direction: -1 | 1): number;
+export declare function pageAnchor(active: number, itemsLength: number, range: ListVisibleRange, direction: -1 | 1): number;
+export declare function nearestVisibleActive(active: number, itemsLength: number, range: ListVisibleRange): number;

package/dist/vue/components/simple-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Style } from "../../core/types.js";
+export declare function clamp(n: number, min: number, max: number): number;
+export declare function mergeStyle(...styles: Array<Style | undefined>): Style;
+export declare function fitCellText(value: unknown, width: number, align?: "left" | "right"): string;
+export declare function repeatToCells(ch: string, width: number): string;

package/dist/vue/components/terminal-provider/copy-toast.d.ts

@@ -0,0 +1,6 @@
+export declare function createCopyToastState(defaultText?: string): {
+    readonly visible: import("vue").Ref<boolean>;
+    readonly text: import("vue").Ref<string>;
+    readonly show: (message?: string) => void;
+    readonly dispose: () => void;
+};

package/dist/vue/components/terminal-provider/portals.d.ts

@@ -0,0 +1,17 @@
+import type { Component } from "vue";
+import type { TerminalRenderPlane } from "../../../core/render-plane.js";
+import type { TerminalRuntimeHandle, TerminalSchedulerInvalidateOptions } from "../../context.js";
+export interface Portal {
+    id: string;
+    component: Component;
+    plane: TerminalRenderPlane;
+    props: Record<string, unknown>;
+}
+export declare function createTerminalPortals(invalidate: (options?: TerminalSchedulerInvalidateOptions) => void): {
+    readonly portals: import("vue").ShallowReactive<Portal[]>;
+    readonly runtime: Readonly<{
+        mount: (component: Component, props: Record<string, unknown>, options?: Readonly<{
+            plane?: TerminalRenderPlane;
+        }>) => TerminalRuntimeHandle;
+    }>;
+};

package/dist/vue/components/terminal-provider/scheduler.d.ts

@@ -0,0 +1,29 @@
+import type { ShallowRef } from "vue";
+import type { Terminal } from "../../../core/types.js";
+import type { FramePerfStore } from "../../../observability/frame-perf-store.js";
+import type { TuiProfiler } from "../../../observability/tui-profiler.js";
+import type { DomRenderer } from "../../../renderer/dom/dom-renderer.js";
+import type { TerminalSchedulerInvalidateOptions } from "../../context.js";
+import type { RenderManager } from "../../render/render-manager.js";
+export declare function createTerminalProviderScheduler(options: {
+    terminal: Terminal;
+    renderer: ShallowRef<DomRenderer | null>;
+    render: RenderManager;
+    framePerf: FramePerfStore;
+    profiler: TuiProfiler | null;
+    isUnmounting: () => boolean;
+    afterFlush: () => void;
+}): {
+    readonly api: Readonly<{
+        invalidate: (options?: TerminalSchedulerInvalidateOptions) => void;
+        flush: () => void;
+        flushNow: () => void;
+        configure: (options: import("../../context.js").TerminalSchedulerConfig) => void;
+        queueFrameTask: (task: import("../../context.js").TerminalFrameTask) => boolean | void;
+        cancelFrameTask?: (id: string) => boolean | void;
+        requestLive: (reason: string) => () => void;
+        dropLive: (reason: string) => void;
+        isInsideFrame: () => boolean;
+    }>;
+    readonly dispose: () => void;
+};

package/dist/vue/components/terminal-provider/selection-config.d.ts

@@ -0,0 +1,15 @@
+import type { TerminalSelectionCopyPayload, TerminalSelectionOptions } from "../../../selection/terminal-selection.js";
+import type { Style } from "../../../core/types.js";
+export type ResolvedTerminalSelectionConfig = Readonly<{
+    enabled: boolean;
+    autoCopy: boolean;
+    copyOnMouseUp: boolean;
+    style: Style;
+    toast: boolean;
+}>;
+export type TerminalProviderSelectionOptions = TerminalSelectionOptions & Readonly<{
+    toast?: boolean;
+}>;
+export type TerminalProviderSelectionConfig = boolean | TerminalProviderSelectionOptions;
+export declare function resolveSelectionConfig(config: TerminalProviderSelectionConfig): ResolvedTerminalSelectionConfig;
+export declare function selectionCopyToastText(payload: TerminalSelectionCopyPayload): string;

package/dist/vue/components/terminal-provider/utils.d.ts

@@ -0,0 +1,5 @@
+import type { DomRendererOptions } from "../../../renderer/dom/dom-renderer.js";
+export declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+export declare function shallowEqualRecord(a: Record<string, unknown>, b: Record<string, unknown>): boolean;
+export declare function warnDev(message: string): void;
+export declare function pickInitOnlyDomOptions(options: DomRendererOptions | undefined): Record<string, unknown>;

package/dist/vue/composables/use-layout.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutContext } from "../context.js";
+export declare function useLayout(): LayoutContext;

package/dist/vue/composables/use-render-node.d.ts

@@ -0,0 +1,19 @@
+import type { Ref } from "vue";
+import type { TerminalSchedulerPriority } from "../context.js";
+import type { RenderRect, RenderStack } from "../render/render-manager.js";
+export interface RenderNodeOptions {
+    zIndex?: number;
+    stack?: RenderStack;
+    rect?: RenderRect | null;
+    /**
+     * One-shot absolute terminal rows for row-local content changes on this node's plane only.
+     * Omit this when geometry, z-order, style, data identity, or paint semantics changed.
+     */
+    dirtyRowsHint?: readonly number[];
+    priority?: TerminalSchedulerPriority;
+    deps?: unknown;
+    paint: (dirtyRows?: readonly number[]) => void;
+}
+export declare function useRenderNode(getOptions: () => RenderNodeOptions): {
+    id: Ref<string | null>;
+};

package/dist/vue/composables/use-render-stack.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from "vue";
+import type { RenderStack } from "../render/render-manager.js";
+export declare function useRenderStack(): Ref<RenderStack>;

package/dist/vue/composables/use-runtime.d.ts

@@ -0,0 +1,5 @@
+export declare function useTerminalRuntime(): Readonly<{
+    mount: (component: import("vue").Component, props: Record<string, unknown>, options?: Readonly<{
+        plane?: import("../../core.js").TerminalRenderPlane;
+    }>) => import("../context.js").TerminalRuntimeHandle;
+}>;

package/dist/vue/composables/use-terminal-node.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from "vue";
+import type { Rect, TerminalEventHandlerMap } from "../../events/manager/types.js";
+export interface TerminalNodeOptions {
+    rect: Rect;
+    zIndex?: number;
+    visible?: boolean;
+    focusable?: boolean;
+    selectable?: boolean;
+    selectionScrollBy?: (deltaRows: number) => boolean | void;
+    handlers?: TerminalEventHandlerMap;
+}
+export declare function useTerminalNode(getOptions: () => TerminalNodeOptions): {
+    id: Ref<string | null>;
+};

package/dist/vue/composables/use-terminal.d.ts

@@ -0,0 +1,2 @@
+import type { TerminalContext } from "../context.js";
+export declare function useTerminal(): TerminalContext;

package/dist/vue/composables/use-visibility.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef, VNode } from "vue";
+export type VisibilityRootProps = Readonly<{
+    style: Readonly<Record<string, string | number>>;
+    onVnodeBeforeMount: (vnode: VNode) => void;
+    onVnodeBeforeUnmount: (vnode: VNode) => void;
+}>;
+export declare function useVisibility(options?: {
+    provide?: boolean;
+}): Readonly<{
+    visible: ComputedRef<boolean>;
+    rootProps: VisibilityRootProps;
+}>;

package/dist/vue/context.d.ts

@@ -0,0 +1,153 @@
+import type { Component, InjectionKey, Ref, ShallowRef } from "vue";
+import type { PathPickerProvider } from "../core/path-provider-types.js";
+import type { TerminalRenderPlane } from "../core/render-plane.js";
+import type { WidthProvider } from "../core/buffer/width.js";
+import type { Style, Terminal } from "../core/types.js";
+import type { EventManager } from "../events/manager/event-manager.js";
+import type { Rect } from "../events/manager/types.js";
+import type { SelectionTextProvider, TerminalSelectionCopyPayload, TerminalSelectionRefreshOptions } from "../selection/terminal-selection.js";
+import type { RendererCapabilities, TerminalRendererLike } from "../renderer/capabilities.js";
+import type { TraceStore } from "../observability/trace.js";
+import type { FramePerfReason } from "../observability/frame-perf.js";
+import type { FramePerfStore } from "../observability/frame-perf-store.js";
+import type { RenderManager } from "./render/render-manager.js";
+export interface LayoutContext {
+    originX: number;
+    originY: number;
+    clipRect: Rect | null;
+}
+export type TerminalSchedulerPriority = "high" | "normal" | "low";
+export type TerminalSchedulerInvalidateOptions = Readonly<{
+    priority?: TerminalSchedulerPriority;
+    plane?: TerminalRenderPlane;
+    reason?: FramePerfReason;
+}>;
+export type TerminalFrameTaskPriority = "high" | "normal" | "low";
+export type TerminalFrameContext = Readonly<{
+    frameId: number;
+    startedAt: number;
+    now: () => number;
+    budgetMs: number;
+    remainingMs: () => number;
+    requestMore: () => void;
+    invalidate: (options?: TerminalSchedulerInvalidateOptions) => void;
+    /**
+     * Internal scheduler metric hook used by frame tasks/mailboxes to report
+     * dropped producer updates that were intentionally coalesced before paint.
+     *
+     * Compatibility note:
+     * TerminalFrameContext is an exported type, so additions here are public.
+     */
+    reportDroppedUpdates?: (count: number) => void;
+    reportMailboxDeliveryAttempt?: (attempt: {
+        id: string;
+        queued: number;
+        dropped: number;
+    }) => void;
+}>;
+export type TerminalFrameTask = Readonly<{
+    id?: string;
+    reason?: FramePerfReason;
+    priority?: TerminalFrameTaskPriority;
+    sync?: boolean;
+    run: (ctx: TerminalFrameContext) => void;
+}>;
+export type TerminalSchedulerConfig = Readonly<{
+    targetFps?: number;
+    maxFps?: number;
+    frameBudgetMs?: number;
+}>;
+export type TerminalScheduler = Readonly<{
+    invalidate: (options?: TerminalSchedulerInvalidateOptions) => void;
+    flush: () => void;
+    /**
+     * Flushes render-manager work and requests a sync terminal commit immediately.
+     * DOM row updates may still defer to rAF when they exceed the renderer sync budget.
+     */
+    flushNow: () => void;
+    configure: (options: TerminalSchedulerConfig) => void;
+    /**
+     * Queues a frame task for the next scheduler frame.
+     * false means the scheduler explicitly rejected the task; producers must clear
+     * local pending state. true or undefined means accepted so legacy schedulers
+     * that do not return a value remain valid.
+     */
+    queueFrameTask: (task: TerminalFrameTask) => boolean | void;
+    /**
+     * Best-effort cancellation for a pending id task.
+     * If the scheduler has already taken the task for the current frame,
+     * the task run() still needs to guard its own stale state.
+     */
+    cancelFrameTask?: (id: string) => boolean | void;
+    requestLive: (reason: string) => () => void;
+    dropLive: (reason: string) => void;
+    isInsideFrame: () => boolean;
+}>;
+export type TerminalRuntimeHandle = Readonly<{
+    update: (props: Record<string, unknown>) => void;
+    move: (x: number, y: number) => void;
+    unmount: () => void;
+}>;
+export type TerminalRuntime = Readonly<{
+    mount: (component: Component, props: Record<string, unknown>, options?: Readonly<{
+        plane?: TerminalRenderPlane;
+    }>) => TerminalRuntimeHandle;
+}>;
+export type TerminalSelectionContext = Readonly<{
+    registerTextProvider: (provider: SelectionTextProvider) => () => void;
+    onCopy: (handler: (payload: TerminalSelectionCopyPayload) => void) => () => void;
+    refresh: (options?: TerminalSelectionRefreshOptions) => void;
+    clear: () => void;
+}>;
+export type ImeAnchor = Readonly<{
+    cellX: number;
+    cellY: number;
+    ownerId?: string;
+}>;
+export type TerminalContext = Readonly<{
+    terminal: Terminal;
+    renderer: Ref<TerminalRendererLike | null>;
+    rendererCapabilities: Ref<RendererCapabilities>;
+    events: Ref<EventManager | null>;
+    scheduler: TerminalScheduler;
+    runtime: TerminalRuntime;
+    observability: Readonly<{
+        trace: TraceStore;
+        framePerf: FramePerfStore;
+    }>;
+    selection: TerminalSelectionContext;
+    defaultStyle: Ref<Style>;
+    widthProvider: WidthProvider;
+    render: RenderManager;
+}>;
+export declare const TerminalContextKey: InjectionKey<Readonly<{
+    terminal: Terminal;
+    renderer: Ref<TerminalRendererLike | null>;
+    rendererCapabilities: Ref<RendererCapabilities>;
+    events: Ref<EventManager | null>;
+    scheduler: TerminalScheduler;
+    runtime: TerminalRuntime;
+    observability: Readonly<{
+        trace: TraceStore;
+        framePerf: FramePerfStore;
+    }>;
+    selection: TerminalSelectionContext;
+    defaultStyle: Ref<Style>;
+    widthProvider: WidthProvider;
+    render: RenderManager;
+}>>;
+export declare const LayoutContextKey: InjectionKey<LayoutContext>;
+export declare const VisibilityContextKey: InjectionKey<Ref<boolean>>;
+export declare const EventZIndexContextKey: InjectionKey<Ref<number>>;
+export declare const RenderPlaneContextKey: InjectionKey<Ref<"default" | "transcript" | "chrome" | "overlay">>;
+export declare const ImeAnchorContextKey: InjectionKey<ShallowRef<Readonly<{
+    cellX: number;
+    cellY: number;
+    ownerId?: string;
+}> | null>>;
+export declare const TInputPluginsContextKey: InjectionKey<Readonly<Ref<readonly Readonly<{
+    name: string;
+    install: (ctx: import("./index.js").TInputPluginContext) => void;
+}>[]>>>;
+export declare const TPathPickerProviderContextKey: InjectionKey<Readonly<Ref<PathPickerProvider | undefined>>>;
+export declare const DialogContextKey: InjectionKey<boolean>;

package/dist/vue/index.d.ts

@@ -0,0 +1,69 @@
+export type { TInputHostAdapter } from "./components/input/host.js";
+export { createTInputHostPlugin } from "./components/input/plugins/hostPlugin.js";
+export { createPromptMentionPlugin } from "./components/input/plugins/promptMentionPlugin.js";
+export type { MentionPathProvider, MentionSuggestionProvider, PromptMentionPluginOptions, } from "./components/input/plugins/promptMentionPlugin.js";
+export { createTextRestrictionPlugin } from "./components/input/plugins/restrictText.js";
+export type { PromptSuggestion, TInputPlugin, TInputPluginContext, } from "./components/input/plugins/types.js";
+export { TAnchor } from "./components/TAnchor.js";
+export { TBox } from "./components/TBox.js";
+export { computeCommandPaletteMatchRanges, TCommandPalette } from "./components/TCommandPalette.js";
+export type { TCommandPaletteItem, TCommandPaletteItemsProvider, TCommandPaletteLoadErrorPayload, TCommandPaletteMatcher, TCommandPaletteMatcherResult, TCommandPaletteMatchRange, TCommandPaletteSelectPayload, } from "./components/TCommandPalette.js";
+export { TDataTable } from "./components/TDataTable.js";
+export type { TDataTableFilterPredicate, TDataTableRowSelectPayload, TDataTableSortChangePayload, TDataTableSortDirection, TDataTableSelectionMode, TDataTableSorter, } from "./components/TDataTable.js";
+export { TDebugOverlay } from "./components/TDebugOverlay.js";
+export { TDialog } from "./components/TDialog.js";
+export type { DialogButton } from "./components/TDialog.js";
+export type { TerminalProviderSelectionConfig, TerminalProviderSelectionOptions, } from "./components/TerminalProvider.js";
+export { TerminalProvider } from "./components/TerminalProvider.js";
+export { TFlow } from "./components/TFlow.js";
+export { TAutocompleteInput, TCheckbox, TForm, TFormContextKey, TFormField, TPasswordInput, TRadioGroup, TSlider, TSwitch, useTForm, } from "./components/TForm.js";
+export type { TAutocompleteLoadErrorPayload, TAutocompleteOption, TAutocompleteSelectPayload, TAutocompleteSuggestionProvider, TFormContext, TFormHandle, TFormModel, TFormRule, TFormSubmitPayload, TRadioOption, } from "./components/TForm.js";
+export { TBadge, TCode, TDivider, TProgress, TSpinner, TTag, TToastViewport, } from "./components/TFeedback.js";
+export type { TFeedbackTone, TToastItem } from "./components/TFeedback.js";
+export { TSplitPane, TTabs } from "./components/TPanels.js";
+export type { TSplitPaneDirection, TSplitPaneRect, TTabsItem } from "./components/TPanels.js";
+export { TInput } from "./components/TInput.js";
+export { TInputBox } from "./components/TInputBox.js";
+export { lintJsonText, TJsonEditor } from "./components/TJsonEditor.js";
+export { TList } from "./components/TList.js";
+export { TLink } from "./components/TLink.js";
+export { TLinkifyText } from "./components/TLinkifyText.js";
+export type { TLinkActivatePayload, TLinkActivationSource, TLinkInvalidHrefPayload, TLinkModifierClick, TLinkOpenMode, TLinkOpenPayload, } from "./components/TLink.js";
+export type { TerminalLinkOpenContext, TerminalLinkOpener, TerminalLinkOpenerLike, TerminalLinkOpenSource, } from "./components/link/host.js";
+export { linkifyTextSegments } from "./linkify.js";
+export type { TLinkifyOptions, TLinkifyProtocol, TLinkifySegment } from "./linkify.js";
+export { TMultilineModal } from "./components/TMultilineModal.js";
+export { TBreadcrumb, TKeyHint, TStatusBar } from "./components/TNavigation.js";
+export type { TBreadcrumbItem, TBreadcrumbSelectPayload } from "./components/TNavigation.js";
+export { TContextMenu, TPopover, TTooltip } from "./components/TOverlay.js";
+export type { TContextMenuItem, TContextMenuSelectPayload } from "./components/TOverlay.js";
+export { TPathPicker } from "./components/TPathPicker.js";
+export { TRenderLayer } from "./components/TRenderLayer.js";
+export { TRenderPlane } from "./components/TRenderPlane.js";
+export { TSelect } from "./components/TSelect.js";
+export type { SelectOption, SelectOptionWithStyle, TSelectMultipleChangePayload, TSelectMultipleEmitMode, TSelectModelValue, TSelectOptionProvider, TSelectValueMode, } from "./components/TSelect.js";
+export { TTable } from "./components/TTable.js";
+export type { TTableColumn, TTableHeaderClickPayload, TTableRow, TTableRowClickPayload, TTableRowKeydownPayload, } from "./components/TTable.js";
+export { TText } from "./components/TText.js";
+export { TTransition } from "./components/TTransition.js";
+export { TTree } from "./components/TTree.js";
+export type { TTreeNode, TTreeSelectPayload, TTreeTogglePayload } from "./components/TTree.js";
+export { TView } from "./components/TView.js";
+export { padEndByCells, sliceByCells, sliceByCellsRange, spaces, textCellWidth, wrapByCells, } from "./utils/text.js";
+export { useLayout } from "./composables/use-layout.js";
+export { useRenderNode } from "./composables/use-render-node.js";
+export { useTerminalRuntime } from "./composables/use-runtime.js";
+export { useTerminalNode } from "./composables/use-terminal-node.js";
+export { useTerminal } from "./composables/use-terminal.js";
+export { useVisibility } from "./composables/use-visibility.js";
+export type { TuiMarkdownTheme, TuiMarkdownThemeOverrides } from "./markdown/theme.js";
+export { createTheme, tuiDefaultTheme } from "./theme.js";
+export { createOverlayFocusStack, resolveOverlayPlacement } from "./overlay.js";
+export type { TOverlayFocusStack, TOverlayPlacement, TOverlayPlacementOptions, TOverlayRect, } from "./overlay.js";
+export type { TuiTheme, TuiThemeColorTokens, TuiThemeComponentTokens, TuiThemeOverrides, } from "./theme.js";
+export type { LayoutContext, TerminalFrameContext, TerminalFrameTask, TerminalFrameTaskPriority, TerminalContext, TerminalSelectionContext, TerminalRuntime, TerminalRuntimeHandle, TerminalScheduler, TerminalSchedulerConfig, TerminalSchedulerInvalidateOptions, } from "./context.js";
+export { TInputPluginsContextKey } from "./context.js";
+export { useRoute, useRouter } from "./router/composables.js";
+export { createTerminalRouter } from "./router/router.js";
+export { TRouterView } from "./router/RouterView.js";
+export type { TerminalRoute, TerminalRouteLocationRaw, TerminalRouter, TerminalRouteRecord, } from "./router/types.js";

package/dist/vue/injection-key.d.ts

@@ -0,0 +1,2 @@
+import type { InjectionKey } from "vue";
+export declare function injectionKey<T>(name: string): InjectionKey<T>;

package/dist/vue/linkify.d.ts

@@ -0,0 +1,11 @@
+export type TLinkifyProtocol = "http" | "https" | "mailto";
+export type TLinkifyOptions = Readonly<{
+    protocols?: readonly TLinkifyProtocol[];
+    allowRelative?: boolean;
+    maxUrlLength?: number;
+}>;
+export type TLinkifySegment = Readonly<{
+    text: string;
+    href?: string;
+}>;
+export declare function linkifyTextSegments(text: string, options?: TLinkifyOptions): readonly TLinkifySegment[];

package/dist/vue/log/append-only-log-store.d.ts

@@ -0,0 +1,2 @@
+import type { AppendOnlyLogStore, CreateAppendOnlyLogStoreOptions } from "./types.js";
+export declare function createAppendOnlyLogStore(options?: CreateAppendOnlyLogStoreOptions): AppendOnlyLogStore;

package/dist/vue/log/tlog-keymap.d.ts

@@ -0,0 +1,28 @@
+export type TLogKeymap = Readonly<{
+    searchNext?: readonly string[];
+    searchPrevious?: readonly string[];
+    clearSearch?: readonly string[];
+    nextLink?: readonly string[];
+    previousLink?: readonly string[];
+    activateLink?: readonly string[];
+}>;
+type KeyboardLike = Readonly<{
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    preventDefault?: () => void;
+}>;
+export declare const tlogDefaultKeymap: TLogKeymap;
+export declare const tlogHighContrastKeymap: TLogKeymap;
+export declare function matchesTLogKeyBinding(event: KeyboardLike, bindings: readonly string[] | undefined): boolean;
+export declare function handleTLogKeymapEvent(event: KeyboardLike, keymap: TLogKeymap, actions: Readonly<{
+    searchNext?: () => void;
+    searchPrevious?: () => void;
+    clearSearch?: () => void;
+    nextLink?: () => boolean;
+    previousLink?: () => boolean;
+    activateLink?: () => boolean;
+}>): boolean;
+export {};

package/dist/vue/log/tlog-plugins.d.ts

@@ -0,0 +1,144 @@
+import type { Style } from "../../core/types.js";
+import type { TLogMinimapDensityBucket } from "../components/TLogMinimap.js";
+import type { TLogViewVisibleLink } from "../components/TLogView.js";
+import type { TLogLinkAction } from "./use-tlog-link-controller.js";
+export type TLogPluginSeverity = "error" | "warning" | "info";
+export type TLogPluginLinkSource = "osc8" | "url" | "plugin";
+export type TLogPluginVisualSegment = Readonly<{
+    text: string;
+    cells: number;
+    style?: Style;
+    href?: string;
+}>;
+export type TLogViewExternalLink = Readonly<{
+    id: string;
+    href: string;
+    text: string;
+    absoluteLineIndex: number;
+    lineIndex: number;
+    startCell: number;
+    endCell: number;
+    source: TLogPluginLinkSource;
+    pluginName?: string;
+    data?: unknown;
+}>;
+export type TLogViewExternalMarker = Readonly<{
+    id: string;
+    absoluteLineIndex: number;
+    lineIndex: number;
+    visualRow: number;
+    estimated?: boolean;
+    current?: boolean;
+    label?: string;
+    severity?: TLogPluginSeverity;
+    source: string;
+    data?: unknown;
+}>;
+export type TLogViewPluginLineMarker = Readonly<{
+    id?: string | number;
+    label?: string;
+    severity?: TLogPluginSeverity;
+    estimated?: boolean;
+    data?: unknown;
+}>;
+export type TLogViewPluginLineLink = Readonly<{
+    id?: string | number;
+    href: string;
+    text: string;
+    startCell: number;
+    endCell: number;
+    source?: TLogPluginLinkSource;
+    data?: unknown;
+}>;
+export type TLogViewPluginLineMetadata = Readonly<{
+    level?: TLogPluginSeverity;
+    markers?: readonly TLogViewPluginLineMarker[];
+    externalLinks?: readonly TLogViewPluginLineLink[];
+    data?: unknown;
+}>;
+export type TLogParsedOsc8Link = Readonly<{
+    href: string;
+    text: string;
+    startCell: number;
+    endCell: number;
+}>;
+export type TLogViewPluginParseLineContext = Readonly<{
+    lineIndex: number;
+    absoluteLineIndex: number;
+    lineKey: string | number;
+    text: string;
+    plainText: string;
+    osc8Links: readonly TLogParsedOsc8Link[];
+}>;
+export type TLogViewPluginDecorateSegmentsContext = Readonly<{
+    lineIndex: number;
+    absoluteLineIndex: number;
+    text: string;
+    plainText: string;
+    metadata: TLogViewPluginLineMetadata | null;
+    segments: readonly TLogPluginVisualSegment[];
+}>;
+export type TLogViewPluginIndexedLine = Readonly<{
+    lineIndex: number;
+    absoluteLineIndex: number;
+    lineKey: string | number;
+    text: string;
+    plainText: string;
+    osc8Links: readonly TLogParsedOsc8Link[];
+    externalLinks: readonly TLogViewExternalLink[];
+    results: readonly Readonly<{
+        pluginName: string;
+        metadata: TLogViewPluginLineMetadata;
+    }>[];
+}>;
+export type TLogViewPluginMarkerContext = Readonly<{
+    lines: readonly TLogViewPluginIndexedLine[];
+    currentMatchLineIndex: number | null;
+    totalVisualRows: number;
+    estimateVisualRow: (lineIndex: number) => number;
+    getMetadata: (line: TLogViewPluginIndexedLine, pluginName: string) => TLogViewPluginLineMetadata | null;
+}>;
+export type TLogViewPluginDensityContext = TLogViewPluginMarkerContext;
+export type TLogViewPlugin = Readonly<{
+    name: string;
+    parseLine?: (ctx: TLogViewPluginParseLineContext) => TLogViewPluginLineMetadata | void;
+    decorateSegments?: (ctx: TLogViewPluginDecorateSegmentsContext) => readonly TLogPluginVisualSegment[] | void;
+    getMarkers?: (ctx: TLogViewPluginMarkerContext) => readonly TLogViewExternalMarker[] | void;
+    getDensityBuckets?: (ctx: TLogViewPluginDensityContext) => readonly TLogMinimapDensityBucket[] | void;
+    onLinkAction?: (action: TLogLinkAction) => void;
+}>;
+export type TLogLevelPluginOptions = Readonly<{
+    errorPattern?: RegExp;
+    warningPattern?: RegExp;
+    infoPattern?: RegExp;
+    includeInfo?: boolean;
+    bucketCount?: number;
+}>;
+export type TLogUrlPluginOptions = Readonly<{
+    pattern?: RegExp;
+    allowFileUrls?: boolean;
+}>;
+export declare function stripTLogAnsiText(text: string): string;
+export declare function parseTLogAnnotatedText(text: string): Readonly<{
+    plainText: string;
+    osc8Links: readonly TLogParsedOsc8Link[];
+}>;
+export declare function detectTLogUrls(text: string, options?: TLogUrlPluginOptions): readonly TLogViewPluginLineLink[];
+export declare function detectTLogLevel(text: string, options?: TLogLevelPluginOptions): TLogPluginSeverity | null;
+export declare function createTLogDensityBucketsFromMarkers(markers: readonly TLogViewExternalMarker[], totalVisualRows: number, bucketCount?: number): readonly TLogMinimapDensityBucket[];
+export declare function getTLogPluginMetadata(line: TLogViewPluginIndexedLine, pluginName: string): TLogViewPluginLineMetadata | null;
+export declare function dispatchTLogPluginLinkAction(plugins: readonly TLogViewPlugin[] | undefined, action: TLogLinkAction): void;
+export declare function createTLogLevelPlugin(options?: TLogLevelPluginOptions): TLogViewPlugin;
+export declare function createTLogOsc8LinkPlugin(): TLogViewPlugin;
+export declare function createTLogUrlPlugin(options?: TLogUrlPluginOptions): TLogViewPlugin;
+export declare function createTLogLinkActionPlugin(options: {
+    name: string;
+    onAction: (action: TLogLinkAction) => void;
+}): TLogViewPlugin;
+export declare function toTLogExternalLinkFromVisibleLink(link: Pick<TLogViewVisibleLink, "href" | "text" | "absoluteLineIndex" | "index" | "startCell" | "endCell">, idPrefix?: string): TLogViewExternalLink;
+export declare function createTLogLineMatcherPlugin(options: {
+    name: string;
+    pattern: RegExp | string;
+    severity?: TLogPluginSeverity;
+    label?: string;
+}): TLogViewPlugin;