@colin_t/lezer-tree-visualizer/dist/index.d.ts

Visualizes a lezer tree to view it in a console

import { SyntaxNode, TreeCursor } from 'lezer-tree';

/**
 * Default terminal colors (4-bit) and helper functions.
 */
declare const Color: {
    readonly Black: ColorType4bit;
    readonly DarkRed: ColorType4bit;
    readonly DarkGreen: ColorType4bit;
    readonly DarkYellow: ColorType4bit;
    readonly DarkBlue: ColorType4bit;
    readonly DarkMagenta: ColorType4bit;
    readonly DarkCyan: ColorType4bit;
    readonly LightGray: ColorType4bit;
    readonly DarkGray: ColorType4bit;
    readonly Red: ColorType4bit;
    readonly Green: ColorType4bit;
    readonly Yellow: ColorType4bit;
    readonly Blue: ColorType4bit;
    readonly Magenta: ColorType4bit;
    readonly BrightCyan: ColorType4bit;
    readonly White: ColorType4bit;
    readonly vsc: {
        readonly Black: ColorType;
        readonly DarkRed: ColorType;
        readonly DarkGreen: ColorType;
        readonly DarkYellow: ColorType;
        readonly DarkBlue: ColorType;
        readonly DarkMagenta: ColorType;
        readonly DarkCyan: ColorType;
        readonly LightGray: ColorType;
        readonly DarkGray: ColorType;
        readonly Red: ColorType;
        readonly Green: ColorType;
        readonly Yellow: ColorType;
        readonly Blue: ColorType;
        readonly Magenta: ColorType;
        readonly BrightCyan: ColorType;
        readonly White: ColorType;
    };
    /**
     * @param color Any color to convert to RGB.
     * @returns The color in RGB format.
     */
    readonly toRGB: (color: ColorType) => RGB;
    /**
     * @see {@link https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit}
     * @param color4bit 4-bit input color.
     * @returns 3-bit output color and the lost bright color bit.
     */
    readonly to3bit: (color4bit: ColorType4bit) => [ColorType3bit, boolean];
    /**
     * Compares two colors of the same color format. If the color format is
     * different, eg. 4-bit and 8-bit, `false` is always returned.
     * @param a First color.
     * @param b Second color.
     * @returns Whether both colors are equal.
     */
    readonly fastEquals: (a: ColorType | null, b: ColorType | null) => boolean;
};
/**
 * Type of a 3-bit color (7 colors).
 * @see {@link https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit}
 */
declare type ColorType3bit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
/**
 * Type of a 4-bit color (7 colors with a brightness bit).
 * @see {@link https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit}
 */
declare type ColorType4bit = ColorType3bit | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
/**
 * Type of an 8-bit color.
 * @see {@link https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit}
 */
declare type ColorType8bit = [5, number];
/**
 * Type of a 24-bit RGB color.
 */
declare type RGB = [number, number, number];
declare type ColorType = ColorType4bit | ColorType8bit | {
    rgb: RGB;
};
/**
 * Used by the {@link Writer} to store the currently selected colors.
 */
declare type ColorState = {
    bg: ColorType | null;
    fg: ColorType | null;
    update_fg: boolean;
    update_bg: boolean;
};

interface IWriter {
    /**
     * Writes a string to the internal buffer.
     * @sealed
     * @param str String to write.
     */
    push(str: string): void;
    /**
     * Sets the foreground color.
     * @param color New color.
     */
    fg(color: ColorType): void;
    /**
     * Sets the background color.
     * @param color New color.
     */
    bg(color: ColorType): void;
    /**
     * Resets the current color to the default.
     * @param fg Foreground color.
     * @param bg Background color.
     */
    resetColor(fg?: boolean, bg?: boolean): void;
    /**
     * Prints the formatted content of this writer in the console.
     */
    print(): void;
    /**
     * Clears the internal buffer but keeps the current colors.
     */
    clear(): void;
    /**
     * @returns The text content of this writer.
     */
    toString(): string;
}
/**
 * A helper class for writing formatted strings.
 */
declare class Writer implements IWriter {
    protected buffer: string;
    protected color: ColorState;
    /**
     * Writes a color marker to the internal buffer.
     * @virtual
     */
    protected pushColor(): void;
    /** @inheritdoc IWriter.push */
    push(str: string): void;
    /** @inheritdoc IWriter.fg */
    fg(color: ColorType): void;
    /** @inheritdoc IWriter.bg */
    bg(color: ColorType): void;
    /** @inheritdoc IWriter.resetColor */
    resetColor(fg?: boolean, bg?: boolean): void;
    /** @inheritdoc IWriter.print */
    print(): void;
    /** @inheritdoc IWriter.clear */
    clear(): void;
    /** @inheritdoc IWriter.toString */
    toString(): string;
}

interface Theme {
    name: ColorType;
    source: ColorType;
    tree: ColorType;
    blockQuotes: ColorType;
    blockReturn: ColorType;
    colon: ColorType;
    ellipsis: ColorType;
}
/**
 * The default color theme for terminals.
 */
declare const defaultOsTheme: Theme;
/**
 * The default color theme for web consoles.
 */
declare const defaultWebTheme: Theme;
/**
 * The default color theme for the current platform.
 */
declare const defaultTheme: Theme;
/**
 * An object that can be used as a source must have the `substring` method.
 */
interface Source {
    substring(from: number, to: number): string;
}
/**
 * @see {@link Options.filter}
 * @returns One of the following values:
 *
 * |Value      |Description                                                   |
 * |-----------|--------------------------------------------------------------|
 * |`Hidden`   |The node is hidden                                            |
 * |`Shown`    |The node is visible                                           |
 * |`Collapsed`|Only the node name is visible, the rest remains as an ellipsis|
 */
declare type FilterFunction = (node: SyntaxNode) => VisibilityModifierValue;
/**
 * @see {@link Options.FilterFunction}
 */
declare const VisibilityModifier: {
    readonly Hidden: 0;
    readonly Shown: 1;
    readonly Collapsed: 2;
};
/**
 * @see {@link Options.FilterFunction}
 */
declare type VisibilityModifierValue = typeof VisibilityModifier[keyof typeof VisibilityModifier];
interface Options {
    /**
     * Whether to use console colors.
     * @defaultValue false
     */
    colors?: boolean;
    /**
     * Whether to log using only one call to `console.log` or one call for
     * each line. This option often looks very ugly in the browser, but it might
     * improve performance and memory usage for very large trees.
     * @defaultValue false
     */
    lineByLine?: boolean;
    /**
     * A function by which nodes are filtered.
     * @param node The node to be filtered.
     */
    filter?: FilterFunction;
    /**
     * Replaces the standard writer. The {@link Options.colors} option is
     * ignored if set.
     */
    writer?: IWriter;
    /**
     * Overrides the {@link defaultTheme | default theme}.
     */
    theme?: Theme;
}
/**
 * Visualizes a syntax tree (or node) by printing it in the console.
 * @param cursor Lezer tree cursor.
 * @param src Source code of the tree.
 * @param colors
 */
declare function visualize(cursor: TreeCursor, src: Source, options?: Options): void;

/**
 * Writes to the console with ANSI escape codes to support terminal colors.
 * @see {@link https://en.wikipedia.org/wiki/ANSI_escape_code#Colors}
 */
declare class OsColorWriter extends Writer {
    /**
     * @inheritdoc IWriter.push
     * @override
     */
    push(str: string): void;
    /**
     * @inheritdoc IWriter.pushColor
     * @override
     */
    protected pushColor(): void;
    /**
     * @inheritdoc IWriter.print
     * @override
     */
    print(): void;
}

/**
 * Writes to the console with CSS format specifiers to support web console colors.
 */
declare class WebColorWriter extends Writer {
    /**
     * CSS Styles appended to the `console.log` call.
     */
    protected styles: string[];
    /**
     * @inheritdoc IWriter.pushColor
     * @override
     */
    protected pushColor(): void;
    /**
     * @inheritdoc IWriter.print
     * @override
     */
    print(): void;
    /**
     * @inheritdoc IWriter.clear
     * @override
     */
    clear(): void;
}

declare const ColorWriter: typeof OsColorWriter | typeof WebColorWriter;

export { Color, ColorState, ColorType, ColorType3bit, ColorType4bit, ColorType8bit, ColorWriter, FilterFunction, IWriter, Options, OsColorWriter, RGB, Source, Theme, VisibilityModifier, VisibilityModifierValue, WebColorWriter, Writer, defaultOsTheme, defaultTheme, defaultWebTheme, visualize };