@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/ink/components/tree-view/use-tree-view-state.d.ts

@@ -0,0 +1,135 @@
+import { TreeNodeMap } from "./tree-node-map.d.ts";
+import type { SelectionMode, TreeNode, TreeNodeState } from "./types.d.ts";
+export type State<T> = {
+    expandedIds: Set<string>;
+    focusedId: string | undefined;
+    loadingIds: Set<string>;
+    nodeMap: TreeNodeMap<T>;
+    previousExpandedIds: Set<string>;
+    previousSelectedIds: Set<string>;
+    selectedIds: Set<string>;
+    selectionMode: SelectionMode;
+    viewportFromIndex: number;
+    viewportToIndex: number;
+    /** O(1) lookup from node ID to index in visibleIds. */
+    visibleIdIndex: Map<string, number>;
+    visibleIds: string[];
+    visibleNodeCount: number;
+};
+export type Action<T> = {
+    nodeId: string;
+    type: "collapse-node";
+} | {
+    nodeId: string;
+    type: "expand-node";
+} | {
+    nodeId: string;
+    type: "set-children-error";
+} | {
+    children: TreeNode<T>[];
+    parentId: string;
+    type: "insert-children";
+} | {
+    isLoading: boolean;
+    nodeId: string;
+    type: "set-loading";
+} | {
+    state: State<T>;
+    type: "reset";
+} | {
+    type: "collapse";
+} | {
+    type: "collapse-all";
+} | {
+    type: "expand";
+} | {
+    type: "expand-all";
+} | {
+    type: "focus-first";
+} | {
+    type: "focus-first-child";
+} | {
+    type: "focus-last";
+} | {
+    type: "focus-next";
+} | {
+    type: "focus-parent";
+} | {
+    type: "focus-previous";
+} | {
+    type: "select";
+} | {
+    type: "toggle-expanded";
+};
+export declare function reducer<T>(state: State<T>, action: Action<T>): State<T>;
+export type CreateDefaultStateProps<T> = {
+    data: TreeNode<T>[];
+    defaultExpanded?: ReadonlySet<string> | "all";
+    defaultSelected?: ReadonlySet<string>;
+    selectionMode: SelectionMode;
+    visibleNodeCount: number;
+};
+export declare function createDefaultState<T>({ data, defaultExpanded, defaultSelected, selectionMode, visibleNodeCount }: CreateDefaultStateProps<T>): State<T>;
+export type UseTreeViewStateProps<T = Record<string, unknown>> = {
+    /** The tree data. Array of root-level nodes. */
+    readonly data: TreeNode<T>[];
+    /**
+     * Set of node IDs that are expanded by default.
+     * If not provided, all nodes start collapsed.
+     */
+    readonly defaultExpanded?: ReadonlySet<string> | "all";
+    /**
+     * Set of node IDs that are selected by default.
+     */
+    readonly defaultSelected?: ReadonlySet<string>;
+    /** Called when expanded set changes. */
+    readonly onExpandChange?: (expandedIds: ReadonlySet<string>) => void;
+    /** Called when the focused node changes. */
+    readonly onFocusChange?: (nodeId: string) => void;
+    /** Called when selection changes. */
+    readonly onSelectChange?: (selectedIds: ReadonlySet<string>) => void;
+    /**
+     * Selection mode.
+     * @default "none"
+     */
+    readonly selectionMode?: SelectionMode;
+    /**
+     * Number of visible nodes in the viewport (for virtualization).
+     * @default Infinity
+     */
+    readonly visibleNodeCount?: number;
+};
+export type TreeViewState<T = Record<string, unknown>> = {
+    readonly collapse: () => void;
+    readonly collapseAll: () => void;
+    readonly collapseNode: (nodeId: string) => void;
+    readonly expand: () => void;
+    readonly expandAll: () => void;
+    readonly expandedIds: ReadonlySet<string>;
+    readonly expandNode: (nodeId: string) => void;
+    readonly focusedId: string | undefined;
+    readonly focusFirst: () => void;
+    readonly focusFirstChild: () => void;
+    readonly focusLast: () => void;
+    readonly focusNext: () => void;
+    readonly focusParent: () => void;
+    readonly focusPrevious: () => void;
+    readonly hasScrollDown: boolean;
+    readonly hasScrollUp: boolean;
+    readonly insertChildren: (parentId: string, children: TreeNode<T>[]) => void;
+    readonly loadingIds: ReadonlySet<string>;
+    readonly nodeMap: TreeNodeMap<T>;
+    readonly select: () => void;
+    readonly selectedIds: ReadonlySet<string>;
+    readonly setChildrenError: (nodeId: string) => void;
+    readonly setLoading: (nodeId: string, isLoading: boolean) => void;
+    readonly toggleExpanded: () => void;
+    readonly viewportFromIndex: number;
+    readonly viewportNodes: {
+        node: TreeNode<T>;
+        state: TreeNodeState;
+    }[];
+    readonly viewportToIndex: number;
+    readonly visibleCount: number;
+};
+export declare function useTreeViewState<T = Record<string, unknown>>({ data, defaultExpanded, defaultSelected, onExpandChange, onFocusChange, onSelectChange, selectionMode, visibleNodeCount, }: UseTreeViewStateProps<T>): TreeViewState<T>;

package/dist/ink/components/tree-view/use-tree-view.d.ts

@@ -0,0 +1,26 @@
+import type { AsyncChildrenFunction, SelectionMode } from "./types.d.ts";
+import type { TreeViewState } from "./use-tree-view-state.d.ts";
+export type UseTreeViewProps<T = Record<string, unknown>> = {
+    /**
+     * When disabled, user input is ignored.
+     * @default false
+     */
+    readonly isDisabled?: boolean;
+    /**
+     * Async function to load children on demand.
+     */
+    readonly loadChildren?: AsyncChildrenFunction<T>;
+    /**
+     * Called when `loadChildren` rejects.
+     */
+    readonly onLoadError?: (nodeId: string, error: Error) => void;
+    /**
+     * Selection mode.
+     */
+    readonly selectionMode: SelectionMode;
+    /**
+     * The tree view state from `useTreeViewState`.
+     */
+    readonly state: TreeViewState<T>;
+};
+export declare function useTreeView<T>({ isDisabled, loadChildren, onLoadError, selectionMode, state }: UseTreeViewProps<T>): void;

package/dist/ink/components/variant-config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared variant configuration for Alert and StatusMessage components.
+ */
+type VariantConfig = {
+    readonly color: string;
+    readonly icon: string;
+};
+export type Variant = "error" | "info" | "success" | "warning";
+declare const VARIANT_CONFIG: Record<Variant, VariantConfig>;
+export default VARIANT_CONFIG;

package/dist/ink/cursor-helpers.d.ts

@@ -0,0 +1,38 @@
+export type CursorPosition = {
+    x: number;
+    y: number;
+};
+declare const showCursorEscape = "\u001B[?25h";
+declare const hideCursorEscape = "\u001B[?25l";
+export { hideCursorEscape, showCursorEscape };
+/**
+ * Compare two cursor positions. Returns true if they differ.
+ */
+export declare const cursorPositionChanged: (a: CursorPosition | undefined, b: CursorPosition | undefined) => boolean;
+/**
+ * Build escape sequence to move cursor from bottom of output to the target position and show it.
+ * Assumes cursor is at (col 0, line visibleLineCount) — i.e. just after the last output line.
+ */
+export declare const buildCursorSuffix: (visibleLineCount: number, cursorPosition: CursorPosition | undefined) => string;
+/**
+ * Build escape sequence to move cursor from previousCursorPosition back to the bottom of output.
+ * This must be done before eraseLines or any operation that assumes cursor is at the bottom.
+ */
+export declare const buildReturnToBottom: (previousLineCount: number, previousCursorPosition: CursorPosition | undefined) => string;
+export type CursorOnlyInput = {
+    cursorPosition: CursorPosition | undefined;
+    cursorWasShown: boolean;
+    previousCursorPosition: CursorPosition | undefined;
+    previousLineCount: number;
+    visibleLineCount: number;
+};
+/**
+ * Build the escape sequence for cursor-only updates (output unchanged, cursor moved).
+ * Hides cursor if it was previously shown, returns to bottom, then repositions.
+ */
+export declare const buildCursorOnlySequence: (input: CursorOnlyInput) => string;
+/**
+ * Build the prefix that hides cursor and returns to bottom before erasing or rewriting.
+ * Returns empty string if cursor was not shown.
+ */
+export declare const buildReturnToBottomPrefix: (cursorWasShown: boolean, previousLineCount: number, previousCursorPosition: CursorPosition | undefined) => string;

package/dist/ink/data-limited-lru-map.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A specialized LRU map that enforces limits on both the number of entries and
+ * the total character length of the keys.
+ *
+ * When adding a new item, if the new key's length would exceed `maxDataSize`,
+ * it evicts the least recently used items until space is available.
+ *
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+declare class DataLimitedLruMap<V> {
+    private readonly map;
+    private readonly maxDataSize;
+    private readonly maxKeys;
+    private currentDataSize;
+    constructor(maxKeys: number, maxDataSize: number);
+    get size(): number;
+    clear(): void;
+    get(key: string): V | undefined;
+    set(key: string, value: V): void;
+}
+export default DataLimitedLruMap;

package/dist/ink/devtools-window-polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ink/devtools.d.ts

@@ -0,0 +1 @@
+import "./devtools-window-polyfill";

package/dist/ink/dom.d.ts

@@ -0,0 +1,213 @@
+import type { Node as YogaNode } from "yoga-layout";
+import type { OutputTransformer } from "./render-node-to-output.d.ts";
+import type ResizeObserver from "./resize-observer.d.ts";
+import type { ScrollState } from "./scroll.d.ts";
+import type { StyledLine } from "./styled-line.d.ts";
+import type { Styles } from "./styles.d.ts";
+type InkNode = {
+    internal_static?: boolean;
+    parentNode: DOMElement | undefined;
+    style: Styles;
+    yogaNode?: YogaNode;
+};
+type LayoutListener = () => void;
+export type TextName = "#text";
+export type ElementNames = "ink-root" | "ink-box" | "ink-text" | "ink-cursor" | "ink-virtual-text" | "ink-static-render";
+/**
+ * Describes a sticky header that should be composited on top of scrolled content.
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+export type StickyHeader = {
+    /** Content-relative end row. */
+    endRow: number;
+    /** Height in rows. */
+    height?: number;
+    /** If true, natural 'lines' are already in background content. */
+    isStuckOnly: boolean;
+    /** Lines rendered in the natural (scrolling) position. */
+    lines: ReadonlyArray<StyledLine>;
+    /** Natural row offset relative to content start. */
+    naturalRow: number;
+    /** Reference to the DOM node for this header. */
+    node?: DOMElement;
+    /** Unique ID of the sticky node. */
+    nodeId: number;
+    /** ID of the scroll container this header belongs to. */
+    scrollContainerId: number | string;
+    /** Content-relative start row. */
+    startRow: number;
+    /** Lines rendered in the stuck (pinned) position, if different. */
+    stuckLines?: ReadonlyArray<StyledLine>;
+    /** Sticky type: top-pinned or bottom-pinned. */
+    type?: "top" | "bottom";
+    /** Stuck X position relative to region. */
+    x: number;
+    /** Stuck Y position relative to region. */
+    y: number;
+};
+export type NodeNames = ElementNames | TextName;
+export type CursorAnchorRef = {
+    readonly current: DOMElement | undefined | null;
+};
+export type CursorMarker = {
+    anchorRef?: CursorAnchorRef;
+    inline?: boolean;
+    x: number;
+    y: number;
+};
+export type DOMElement = InkNode & {
+    attributes: Record<string, DOMNodeAttribute>;
+    /**
+     * Cached render result (a Region). When set, the entire subtree is
+     * skipped during rendering and the cached region is composited directly.
+     * Set by setCachedRender(), cleared on unmount by cleanupNodeTree().
+     */
+    cachedRender?: import("./region").Region;
+    childNodes: DOMNode[];
+    internal_accessibility?: {
+        role?: "button" | "checkbox" | "combobox" | "list" | "listbox" | "listitem" | "menu" | "menuitem" | "option" | "progressbar" | "radio" | "radiogroup" | "tab" | "tablist" | "table" | "textbox" | "timer" | "toolbar";
+        state?: {
+            busy?: boolean;
+            checked?: boolean;
+            disabled?: boolean;
+            expanded?: boolean;
+            multiline?: boolean;
+            multiselectable?: boolean;
+            readonly?: boolean;
+            required?: boolean;
+            selected?: boolean;
+        };
+    };
+    internal_cursor?: CursorMarker;
+    internal_hidden?: boolean;
+    /**
+     * Auto-incrementing unique identifier for this node.
+     */
+    internal_id: number;
+    /**
+     * Whether this element's scrollback buffer is dirty (needs recalculation).
+     */
+    internal_isScrollbackDirty?: boolean;
+    /**
+     * Last measured size for ResizeObserver tracking.
+     */
+    internal_lastMeasuredSize?: {
+        height: number;
+        width: number;
+    };
+    internal_layoutListeners?: Set<LayoutListener>;
+    /**
+     * Maximum scrollTop ever reached, used with stableScrollback.
+     */
+    internal_maxScrollTop?: number;
+    /**
+     * Whether this element is opaque (prevents rendering of covered content beneath it).
+     */
+    internal_opaque?: boolean;
+    /**
+     * Whether the scrollbar should be rendered for this scrollable element.
+     * Defaults to true for elements with overflow: 'scroll'.
+     */
+    internal_scrollbar?: boolean;
+    /**
+     * Scroll state computed by calculateScroll() for elements with overflow: 'scroll'.
+     */
+    internal_scrollState?: ScrollState;
+    /**
+     * Whether this element is sticky (pinned during scroll).
+     * - `true` or `'top'`: pinned to the top of the scroll container
+     * - `'bottom'`: pinned to the bottom of the scroll container
+     */
+    internal_sticky?: boolean | "top" | "bottom";
+    /**
+     * Whether this element is the alternate (stuck) version of a sticky header.
+     * The stuck version is rendered when the header is pinned.
+     */
+    internal_stickyAlternate?: boolean;
+    /**
+     * Whether this element should receive the terminal cursor focus.
+     */
+    internal_terminalCursorFocus?: boolean;
+    /**
+     * Terminal cursor position offset within this element.
+     */
+    internal_terminalCursorPosition?: number;
+    /**
+     * Cached text squash result for this node's subtree.
+     * Invalidated by markNodeAsDirty() when children change.
+     */
+    internal_textCache?: {
+        map: Map<DOMNode, {
+            end: number;
+            start: number;
+        }>;
+        text: string;
+    };
+    internal_transform?: OutputTransformer;
+    isStaticDirty?: boolean;
+    /**
+     * Callback invoked after prepareYogaTree() caches the render output for
+     * an ink-static-render node. StaticRender uses this to set `isRendered`
+     * state, which prevents React from re-reconciling children once cached.
+     */
+    internal_onRendered?: () => void;
+    /**
+     * Whether the Yoga subtree has been detached (children removed from Yoga layout)
+     * because a cachedRender was set. When cachedRender is invalidated,
+     * prepareYogaTree() re-attaches the children before the next layout pass.
+     */
+    isYogaTreeDetached?: boolean;
+    nodeName: ElementNames;
+    onComputeLayout?: () => void;
+    onImmediateRender?: () => void;
+    onRender?: () => void;
+    /**
+     * Set of ResizeObservers attached to this element.
+     */
+    resizeObservers?: Set<ResizeObserver>;
+    staticNode?: DOMElement;
+};
+export type TextNode = InkNode & {
+    nodeName: TextName;
+    nodeValue: string;
+};
+export type DOMNode<T = {
+    nodeName: NodeNames;
+}> = T extends {
+    nodeName: infer U;
+} ? U extends "#text" ? TextNode : DOMElement : never;
+export type DOMNodeAttribute = boolean | string | number;
+export declare const createNode: (nodeName: ElementNames) => DOMElement;
+export declare const appendChildNode: (node: DOMElement, childNode: DOMElement) => void;
+export declare const insertBeforeNode: (node: DOMElement, newChildNode: DOMNode, beforeChildNode: DOMNode) => void;
+export declare const removeChildNode: (node: DOMElement, removeNode: DOMNode) => void;
+export declare const setAttribute: (node: DOMElement, key: string, value: DOMNodeAttribute) => void;
+export declare const setStyle: (node: DOMNode, style?: Styles) => void;
+export declare const createTextNode: (text: string) => TextNode;
+export declare const markNodeAsDirty: (node?: DOMNode) => void;
+export declare const setTextNodeValue: (node: TextNode, text: string) => void;
+export declare const addLayoutListener: (rootNode: DOMElement, listener: LayoutListener) => () => void;
+export declare const emitLayoutListeners: (rootNode: DOMElement) => void;
+/**
+ * Store a cached render result on a DOM node. Fixes the Yoga node
+ * dimensions to match the cached region and removes all Yoga children
+ * (since rendering is cached, child layout is no longer needed).
+ *
+ * Ported from jacob314/ink (Google LLC, Apache-2.0).
+ */
+export declare const setCachedRender: (node: DOMElement, cachedRender: import("./region").Region) => void;
+/**
+ * Get the path from the root to this node (inclusive).
+ * Returns an array starting with the root and ending with the node.
+ *
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+export declare const getPathToRoot: (node: DOMNode) => DOMNode[];
+/**
+ * Check if a node is selectable by walking up the tree checking `userSelect` style.
+ * Returns true by default unless an ancestor has `userSelect: 'none'`.
+ *
+ * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
+ */
+export declare const isNodeSelectable: (node: DOMElement) => boolean;
+export {};

package/dist/ink/get-max-width.d.ts

@@ -0,0 +1,3 @@
+import type { Node as YogaNode } from "yoga-layout";
+declare const getMaxWidth: (yogaNode: YogaNode) => number;
+export default getMaxWidth;

package/dist/ink/highlighter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Singleton Shiki highlighter for terminal syntax highlighting.
+ *
+ * Uses codeToTokens() to produce ThemedToken[][] which are mapped
+ * to Ink React elements by token-to-elements.tsx.
+ */
+import type { Highlighter, TokensResult } from "shiki";
+/**
+ * Get cached tokens or compute and cache them.
+ */
+export declare const getCachedTokens: (highlighter: Highlighter, code: string, lang: string, theme: string) => TokensResult;
+/**
+ * Resolve a language name to a canonical name, handling aliases.
+ */
+export declare const resolveLanguage: (lang: string) => string;
+/**
+ * Check if a language is supported.
+ */
+export declare const isLanguageSupported: (lang: string) => boolean;
+/**
+ * Get or create the singleton Shiki highlighter, optionally loading languages and themes.
+ */
+declare const getHighlighter: (languages?: string[], theme?: string) => Promise<Highlighter>;
+/**
+ * Dispose the singleton highlighter, freeing resources.
+ */
+export declare const disposeHighlighter: () => void;
+export default getHighlighter;

package/dist/ink/hooks/use-animation.d.ts

@@ -0,0 +1,43 @@
+type Options = {
+    /**
+     * Time between ticks in milliseconds.
+     *
+     * @default 100
+     */
+    readonly interval?: number;
+    /**
+     * Whether the animation is running. When set to `false`, the animation stops.
+     * When toggled back to `true`, all values reset to `0`.
+     *
+     * @default true
+     */
+    readonly isActive?: boolean;
+};
+export type AnimationResult = {
+    /**
+     * Time in milliseconds since the previous rendered tick. Accounts for throttled renders.
+     * Useful for physics-based or velocity-driven motion: `position += speed * delta`.
+     */
+    readonly delta: number;
+    /**
+     * Discrete counter that increments by 1 each interval.
+     * Useful for indexed sequences like spinner frames.
+     */
+    readonly frame: number;
+    /**
+     * Resets `frame`, `time`, and `delta` to `0` and restarts timing from the current moment.
+     * Useful for one-shot animations triggered by events.
+     */
+    readonly reset: () => void;
+    /**
+     * Total elapsed time in milliseconds since the animation started or was last reset.
+     * Useful for continuous math-based animations like sine waves: `Math.sin(time / 1000 * Math.PI * 2)`.
+     */
+    readonly time: number;
+};
+/**
+ * A React hook that drives animations. Returns a frame counter, elapsed time, frame delta, and a reset function.
+ * All animations share a single timer internally, so multiple animated components consolidate into one render cycle.
+ */
+export default function useAnimation(options?: Options): AnimationResult;
+export {};

package/dist/ink/hooks/use-app.d.ts

@@ -0,0 +1,6 @@
+import type { Props } from "../components/AppContext.d.ts";
+/**
+ * A React hook that returns app lifecycle methods like `exit()` and `waitUntilRenderFlush()`.
+ */
+declare const useApp: () => Props;
+export default useApp;

package/dist/ink/hooks/use-box-metrics.d.ts

@@ -0,0 +1,58 @@
+import type { RefObject } from "react";
+import type { DOMElement } from '../dom.d.ts';
+/**
+ * Metrics of a box element.
+ *
+ * All positions are relative to the element's parent.
+ */
+export type BoxMetrics = {
+    /**
+     * Element height.
+     */
+    readonly height: number;
+    /**
+     * Distance from the left edge of the parent.
+     */
+    readonly left: number;
+    /**
+     * Distance from the top edge of the parent.
+     */
+    readonly top: number;
+    /**
+     * Element width.
+     */
+    readonly width: number;
+};
+export type UseBoxMetricsResult = BoxMetrics & {
+    /**
+     * Whether the currently tracked element has been measured in the latest layout pass.
+     */
+    readonly hasMeasured: boolean;
+};
+/**
+ * A React hook that returns the current layout metrics for a tracked box element.
+ * It updates when layout changes (for example terminal resize, sibling/content changes, or position changes).
+ *
+ * The hook returns `{width: 0, height: 0, left: 0, top: 0}` until the first layout pass completes. It also returns zeros when the tracked ref is detached.
+ *
+ * Use `hasMeasured` to detect when the currently tracked element has been measured.
+ * @example
+ * ```tsx
+import {useRef} from 'react';
+import {Box, Text, useBoxMetrics} from 'ink';
+ 
+const Example = () => {
+    const ref = useRef(null);
+    const {width, height, left, top, hasMeasured} = useBoxMetrics(ref);
+    return (
+        <Box ref={ref}>
+            <Text>
+                {hasMeasured ? `${width}x${height} at ${left},${top}` : 'Measuring...'}
+            </Text>
+        </Box>
+    );
+};
+```
+ */
+declare const useBoxMetrics: (ref: RefObject<DOMElement>) => UseBoxMetricsResult;
+export default useBoxMetrics;

package/dist/ink/hooks/use-clipboard.d.ts

@@ -0,0 +1,29 @@
+import type { ClipboardTarget } from "../clipboard.d.ts";
+export type UseClipboardOptions = {
+    /**
+     * The clipboard target to write to.
+     * @default "c"
+     */
+    readonly target?: ClipboardTarget;
+};
+export type UseClipboardResult = {
+    /**
+     * Copy text to the system clipboard.
+     * No-op if the terminal does not support OSC 52.
+     */
+    readonly copy: (text: string) => void;
+    /**
+     * Whether the current terminal supports OSC 52 clipboard operations.
+     */
+    readonly isSupported: boolean;
+};
+/**
+ * Hook that provides clipboard write access via OSC 52.
+ *
+ * ```tsx
+ * const { copy, isSupported } = useClipboard();
+ * copy("Hello, clipboard!");
+ * ```
+ */
+declare const useClipboard: (options?: UseClipboardOptions) => UseClipboardResult;
+export default useClipboard;

package/dist/ink/hooks/use-color-blindness.d.ts

@@ -0,0 +1,33 @@
+import type { ColorBlindnessType, ColorMatrix } from "../color-matrix.d.ts";
+export type UseColorBlindnessOptions = {
+    /**
+     * Use compensation mode (shift colors to distinguishable range)
+     * instead of simulation mode (show how colors appear to affected users).
+     * Not available for achromatopsia.
+     * @default false
+     */
+    readonly compensate?: boolean;
+    /**
+     * Type of color vision deficiency to simulate or compensate for.
+     * @default "none"
+     */
+    readonly mode?: ColorBlindnessType | "none";
+};
+export type UseColorBlindnessResult = {
+    /** Whether a transform is active (mode is not "none"). */
+    readonly isActive: boolean;
+    /** The active color matrix. */
+    readonly matrix: ColorMatrix;
+    /** Transform a hex color string through the active matrix. */
+    readonly transformColor: (hex: string) => string;
+};
+/**
+ * Hook for color blindness simulation and compensation.
+ *
+ * ```tsx
+ * const { transformColor } = useColorBlindness({ mode: "deuteranopia" });
+ * <Text color={transformColor("#ff0000")}>This text</Text>
+ * ```
+ */
+declare const useColorBlindness: (options?: UseColorBlindnessOptions) => UseColorBlindnessResult;
+export default useColorBlindness;