@andrew_l/vue-stdout 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,608 @@
+import * as vue from 'vue';
+import { FunctionalComponent, MaybeRefOrGetter, ShallowRef } from 'vue';
+import { ForegroundColorName } from 'ansi-styles';
+import { Boxes, BoxStyle } from 'cli-boxes';
+import { LiteralUnion } from 'type-fest';
+import { ForegroundColorName as ForegroundColorName$1 } from 'chalk';
+import { EventEmitter } from 'node:events';
+import { Node } from 'yoga-wasm-web/auto';
+import * as _vue_runtime_core from '@vue/runtime-core';
+import * as _andrew_l_toolkit from '@andrew_l/toolkit';
+import { AnyFunction, Fn } from '@andrew_l/toolkit';
+
+type Styles = {
+    readonly textWrap?: 'wrap' | 'end' | 'middle' | 'truncate-end' | 'truncate' | 'truncate-middle' | 'truncate-start';
+    readonly position?: 'absolute' | 'relative';
+    /**
+     * Size of the gap between an element's columns.
+     */
+    readonly columnGap?: number;
+    /**
+     * Size of the gap between element's rows.
+     */
+    readonly rowGap?: number;
+    /**
+     * Size of the gap between an element's columns and rows. Shorthand for `columnGap` and `rowGap`.
+     */
+    readonly gap?: number;
+    /**
+     * Margin on all sides. Equivalent to setting `marginTop`, `marginBottom`, `marginLeft` and `marginRight`.
+     */
+    readonly margin?: number;
+    /**
+     * Horizontal margin. Equivalent to setting `marginLeft` and `marginRight`.
+     */
+    readonly marginX?: number;
+    /**
+     * Vertical margin. Equivalent to setting `marginTop` and `marginBottom`.
+     */
+    readonly marginY?: number;
+    /**
+     * Top margin.
+     */
+    readonly marginTop?: number;
+    /**
+     * Bottom margin.
+     */
+    readonly marginBottom?: number;
+    /**
+     * Left margin.
+     */
+    readonly marginLeft?: number;
+    /**
+     * Right margin.
+     */
+    readonly marginRight?: number;
+    /**
+     * Padding on all sides. Equivalent to setting `paddingTop`, `paddingBottom`, `paddingLeft` and `paddingRight`.
+     */
+    readonly padding?: number;
+    /**
+     * Horizontal padding. Equivalent to setting `paddingLeft` and `paddingRight`.
+     */
+    readonly paddingX?: number;
+    /**
+     * Vertical padding. Equivalent to setting `paddingTop` and `paddingBottom`.
+     */
+    readonly paddingY?: number;
+    /**
+     * Top padding.
+     */
+    readonly paddingTop?: number;
+    /**
+     * Bottom padding.
+     */
+    readonly paddingBottom?: number;
+    /**
+     * Left padding.
+     */
+    readonly paddingLeft?: number;
+    /**
+     * Right padding.
+     */
+    readonly paddingRight?: number;
+    /**
+     * This property defines the ability for a flex item to grow if necessary.
+     * See [flex-grow](https://css-tricks.com/almanac/properties/f/flex-grow/).
+     */
+    readonly flexGrow?: number;
+    /**
+     * It specifies the “flex shrink factor”, which determines how much the flex item will shrink relative to the rest of the flex items in the flex container when there isn’t enough space on the row.
+     * See [flex-shrink](https://css-tricks.com/almanac/properties/f/flex-shrink/).
+     */
+    readonly flexShrink?: number;
+    /**
+     * It establishes the main-axis, thus defining the direction flex items are placed in the flex container.
+     * See [flex-direction](https://css-tricks.com/almanac/properties/f/flex-direction/).
+     */
+    readonly flexDirection?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    /**
+     * It specifies the initial size of the flex item, before any available space is distributed according to the flex factors.
+     * See [flex-basis](https://css-tricks.com/almanac/properties/f/flex-basis/).
+     */
+    readonly flexBasis?: number | string;
+    /**
+     * It defines whether the flex items are forced in a single line or can be flowed into multiple lines. If set to multiple lines, it also defines the cross-axis which determines the direction new lines are stacked in.
+     * See [flex-wrap](https://css-tricks.com/almanac/properties/f/flex-wrap/).
+     */
+    readonly flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    /**
+     * The align-items property defines the default behavior for how items are laid out along the cross axis (perpendicular to the main axis).
+     * See [align-items](https://css-tricks.com/almanac/properties/a/align-items/).
+     */
+    readonly alignItems?: 'flex-start' | 'center' | 'flex-end' | 'stretch';
+    /**
+     * It makes possible to override the align-items value for specific flex items.
+     * See [align-self](https://css-tricks.com/almanac/properties/a/align-self/).
+     */
+    readonly alignSelf?: 'flex-start' | 'center' | 'flex-end' | 'auto';
+    /**
+     * It defines the alignment along the main axis.
+     * See [justify-content](https://css-tricks.com/almanac/properties/j/justify-content/).
+     */
+    readonly justifyContent?: 'flex-start' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly' | 'center';
+    /**
+     * Width of the element in spaces.
+     * You can also set it in percent, which will calculate the width based on the width of parent element.
+     */
+    readonly width?: number | string;
+    /**
+     * Height of the element in lines (rows).
+     * You can also set it in percent, which will calculate the height based on the height of parent element.
+     */
+    readonly height?: number | string;
+    /**
+     * Sets a minimum width of the element.
+     */
+    readonly minWidth?: number | string;
+    /**
+     * Sets a minimum height of the element.
+     */
+    readonly minHeight?: number | string;
+    /**
+     * Set this property to `none` to hide the element.
+     */
+    readonly display?: 'flex' | 'none';
+    /**
+     * Add a border with a specified style.
+     * If `borderStyle` is `undefined` (which it is by default), no border will be added.
+     */
+    readonly borderStyle?: keyof Boxes | BoxStyle;
+    /**
+     * Determines whether top border is visible.
+     *
+     * @default true
+     */
+    readonly borderTop?: boolean;
+    /**
+     * Determines whether bottom border is visible.
+     *
+     * @default true
+     */
+    readonly borderBottom?: boolean;
+    /**
+     * Determines whether left border is visible.
+     *
+     * @default true
+     */
+    readonly borderLeft?: boolean;
+    /**
+     * Determines whether right border is visible.
+     *
+     * @default true
+     */
+    readonly borderRight?: boolean;
+    /**
+     * Change border color.
+     * Shorthand for setting `borderTopColor`, `borderRightColor`, `borderBottomColor` and `borderLeftColor`.
+     */
+    readonly borderColor?: LiteralUnion<ForegroundColorName, string>;
+    /**
+     * Change top border color.
+     * Accepts the same values as `color` in `Text` component.
+     */
+    readonly borderTopColor?: LiteralUnion<ForegroundColorName, string>;
+    /**
+     * Change bottom border color.
+     * Accepts the same values as `color` in `Text` component.
+     */
+    readonly borderBottomColor?: LiteralUnion<ForegroundColorName, string>;
+    /**
+     * Change left border color.
+     * Accepts the same values as `color` in `Text` component.
+     */
+    readonly borderLeftColor?: LiteralUnion<ForegroundColorName, string>;
+    /**
+     * Change right border color.
+     * Accepts the same values as `color` in `Text` component.
+     */
+    readonly borderRightColor?: LiteralUnion<ForegroundColorName, string>;
+    /**
+     * Dim the border color.
+     * Shorthand for setting `borderTopDimColor`, `borderBottomDimColor`, `borderLeftDimColor` and `borderRightDimColor`.
+     *
+     * @default false
+     */
+    readonly borderDimColor?: boolean;
+    /**
+     * Dim the top border color.
+     *
+     * @default false
+     */
+    readonly borderTopDimColor?: boolean;
+    /**
+     * Dim the bottom border color.
+     *
+     * @default false
+     */
+    readonly borderBottomDimColor?: boolean;
+    /**
+     * Dim the left border color.
+     *
+     * @default false
+     */
+    readonly borderLeftDimColor?: boolean;
+    /**
+     * Dim the right border color.
+     *
+     * @default false
+     */
+    readonly borderRightDimColor?: boolean;
+    /**
+     * Behavior for an element's overflow in both directions.
+     *
+     * @default 'visible'
+     */
+    readonly overflow?: 'visible' | 'hidden';
+    /**
+     * Behavior for an element's overflow in horizontal direction.
+     *
+     * @default 'visible'
+     */
+    readonly overflowX?: 'visible' | 'hidden';
+    /**
+     * Behavior for an element's overflow in vertical direction.
+     *
+     * @default 'visible'
+     */
+    readonly overflowY?: 'visible' | 'hidden';
+};
+
+interface BoxProps extends Styles {
+}
+declare const Box: FunctionalComponent<BoxProps>;
+
+interface NewLineProps {
+    count?: number;
+}
+declare const NewLine: FunctionalComponent<NewLineProps>;
+
+interface TextProps {
+    /**
+     * Change text color. Ink uses chalk under the hood, so all its functionality is supported.
+     */
+    readonly color?: LiteralUnion<ForegroundColorName$1, string>;
+    /**
+     * Same as `color`, but for background.
+     */
+    readonly backgroundColor?: LiteralUnion<ForegroundColorName$1, string>;
+    /**
+     * Dim the color (emit a small amount of light).
+     */
+    readonly dimColor?: boolean;
+    /**
+     * Make the text bold.
+     */
+    readonly bold?: boolean;
+    /**
+     * Make the text italic.
+     */
+    readonly italic?: boolean;
+    /**
+     * Make the text underlined.
+     */
+    readonly underline?: boolean;
+    /**
+     * Make the text crossed with a line.
+     */
+    readonly strikethrough?: boolean;
+    /**
+     * Inverse background and foreground colors.
+     */
+    readonly inverse?: boolean;
+    /**
+     * This property tells Ink to wrap or truncate text if its width is larger than container.
+     * If `wrap` is passed (by default), Ink will wrap text and split it into multiple lines.
+     * If `truncate-*` is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.
+     */
+    readonly wrap?: Styles['textWrap'];
+}
+declare const Text: FunctionalComponent<TextProps>;
+
+interface ProgressBarProps {
+    value: number;
+    min?: number;
+    max?: number;
+    color?: TextProps['color'];
+    backgroundColor?: TextProps['backgroundColor'];
+    showPercent?: boolean;
+    variant?: Styles['borderStyle'];
+}
+declare const ProgressBar: vue.DefineSetupFnComponent<ProgressBarProps, {}, {}, ProgressBarProps & {}, vue.PublicProps>;
+
+/**
+ * Basic node tree implementation
+ */
+declare class NodeTree<T extends NodeTree<T>> extends EventEmitter {
+    readonly nodeName: string;
+    parentNode: T | null;
+    childNodes: T[];
+    getDisplayName(): string;
+    getDisplayData(): Record<string, any>;
+    toJSON(): any;
+    get lastChild(): T | null;
+    get firstChild(): T | null;
+    get nextSibling(): T | null;
+    get previousSibling(): T | null;
+    appendChild(node: T): void;
+    removeChild(node: T): void;
+    insertBefore(child: T, ref?: T | null): void;
+    remove(): void;
+    /** @internal */
+    destroy(): void;
+}
+
+declare enum DOMNodeType {
+    DOCUMENT = 0,
+    ELEMENT_NODE = 1,
+    TEXT_NODE = 3,
+    COMMENT_NODE = 8
+}
+interface DOMRect {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+}
+declare class DOMNode extends NodeTree<DOMNode> {
+    readonly id: number;
+    readonly nodeType: DOMNodeType;
+    readonly nodeName: string;
+    /** @internal */
+    computedBoundingClientRect: DOMRect;
+    /** @internal */
+    root: DOMDocument | null;
+    constructor();
+    insertBefore(child: DOMNode, ref?: DOMNode | null | undefined): void;
+    remove(): void;
+    setRootDocument(document: DOMDocument | null): void;
+    getBoundingClientRect(): DOMRect;
+    getDisplayData(): Record<string, any>;
+    emitRoot(eventName: string, ...args: any[]): void;
+    get textContent(): string | null;
+    set textContent(value: string | null);
+}
+
+declare class DOMComment extends DOMNode {
+    readonly nodeType: DOMNodeType.COMMENT_NODE;
+    readonly nodeName: string;
+    /** @internal */
+    textValue: string | null;
+    constructor(data?: string | null);
+    get textContent(): string | null;
+    set textContent(value: string | null);
+    getDisplayData(): Record<string, any>;
+}
+
+declare class DOMElement extends DOMNode {
+    readonly nodeType: DOMNodeType.ELEMENT_NODE;
+    readonly nodeName: string;
+    readonly tagName: string;
+    readonly attributes: Record<string, any>;
+    constructor(tagName: string);
+    getDisplayName(): string;
+    getDisplayData(): any;
+    getAttribute(name: string): any;
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    set textContent(value: string);
+    get textContent(): string;
+}
+
+declare class DOMText extends DOMNode {
+    readonly nodeType = DOMNodeType.TEXT_NODE;
+    readonly nodeName: string;
+    /** @internal */
+    textValue: string | null;
+    constructor(data?: string | null);
+    get textContent(): string | null;
+    set textContent(value: string | null);
+    getDisplayData(): any;
+    getDisplayName(): string;
+}
+
+declare class DOMDocument extends DOMNode {
+    readonly nodeType: DOMNodeType.DOCUMENT;
+    readonly nodeName: string;
+    static createDocument(): DOMDocument;
+    static createTextNode(data?: string): DOMText;
+    static createComment(data?: string): DOMComment;
+    static createElement(tagName: string): DOMElement;
+    insertBefore(child: DOMNode, ref?: DOMNode | null | undefined): void;
+    get treeText(): string;
+}
+
+type OutputTransformer = (s: string, index: number) => string;
+/**
+ * "Virtual" output class
+ *
+ * Handles the positioning and saving of the output of each node in the tree.
+ * Also responsible for applying transformations to each character of the output.
+ *
+ * Used to generate the final output of all nodes before writing it to actual output stream (e.g. stdout)
+ */
+type Options = {
+    width: number;
+    height: number;
+};
+type Clip = {
+    x1: number | undefined;
+    x2: number | undefined;
+    y1: number | undefined;
+    y2: number | undefined;
+};
+declare class Layer {
+    width: number;
+    height: number;
+    frame: string;
+    frameHeight: number;
+    private readonly operations;
+    constructor(options: Options);
+    write(x: number, y: number, text: string, options: {
+        transformers: OutputTransformer[];
+    }): void;
+    clip(clip: Clip): void;
+    unclip(): void;
+    compute(): void;
+}
+
+declare enum RenderNodeType {
+    NODE = 1,
+    BLOCK = 2,
+    INLINE = 3,
+    TEXT = 4
+}
+interface RenderNodeRect {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+}
+declare class RenderNode extends NodeTree<RenderNode> {
+    readonly id: number;
+    readonly nodeType: RenderNodeType;
+    readonly nodeName: string;
+    transformers: OutputTransformer[];
+    /** @internal */
+    domNode: DOMNode | null;
+    /** @internal */
+    yogaNode: Node;
+    realX: number;
+    realY: number;
+    constructor();
+    getDisplayName(): string;
+    getDisplayData(): Record<string, any>;
+    remove(): void;
+    destroy(): void;
+    insertBefore(child: RenderNode, ref?: RenderNode | null | undefined): void;
+    getComputedRect(): RenderNodeRect;
+    getContentRect(): RenderNodeRect;
+    renderToLayer(layer: Layer): void;
+    computeStyles(): void;
+}
+
+interface RenderFlowOptions {
+    document: DOMDocument;
+    width: number;
+    height: number;
+}
+declare class RenderFlow extends RenderNode {
+    /** @internal */
+    document: DOMDocument;
+    readonly nodeType: RenderNodeType;
+    readonly nodeName: string;
+    height: number;
+    width: number;
+    layer: Layer;
+    reflowScheduled: boolean;
+    constructor({ document, width, height }: RenderFlowOptions);
+    get treeText(): string;
+    /** @internal */
+    onDOMChanged(): void;
+    render(): string;
+    /** @internal */
+    renderNode(node: RenderNode): void;
+    reflow(): void;
+    reflowSchedule(): void;
+    /** @internal */
+    reflowNode(domNode: DOMNode, renderNode: RenderNode): void;
+    /** @internal */
+    reflowAsBlock(domNode: DOMNode, renderNode: RenderNode): void;
+    /** @internal */
+    reflowAsInline(domNode: DOMNode, renderNode: RenderNode): void;
+}
+
+interface ContainerOptions {
+    stdout: NodeJS.WriteStream;
+    stdin: NodeJS.ReadStream;
+    stderr: NodeJS.WriteStream;
+    debug: boolean;
+    exitOnCtrlC: boolean;
+}
+declare class Container extends DOMDocument {
+    tagName: string;
+    stdout: NodeJS.WriteStream;
+    stdin: NodeJS.ReadStream;
+    stderr: NodeJS.WriteStream;
+    exitOnCtrlC: boolean;
+    flow: RenderFlow;
+    write: (...args: any[]) => void;
+    constructor({ debug, exitOnCtrlC, stderr, stdin, stdout }: ContainerOptions);
+    onResize(): void;
+    onFrame(): void;
+}
+declare function createContainer(options?: Partial<ContainerOptions>): Container;
+
+declare const DOM: Readonly<{
+    readonly Document: typeof DOMDocument;
+    readonly Text: typeof DOMText;
+    readonly Comment: typeof DOMComment;
+    readonly Element: typeof DOMElement;
+    readonly Node: typeof DOMNode;
+    readonly Type: typeof DOMNodeType;
+    readonly createDocument: typeof DOMDocument.createDocument;
+    readonly createComment: typeof DOMDocument.createComment;
+    readonly createTextNode: typeof DOMDocument.createTextNode;
+    readonly createElement: typeof DOMDocument.createElement;
+}>;
+
+declare const createApp: _vue_runtime_core.CreateAppFunction<DOMElement | DOMDocument>;
+
+declare class RenderBlock extends RenderNode {
+    readonly nodeType: RenderNodeType;
+    readonly nodeName: string;
+    constructor();
+    renderToLayer(layer: Layer): void;
+}
+
+declare class RenderInline extends RenderNode {
+    readonly nodeType: RenderNodeType.INLINE;
+    readonly nodeName: string;
+    constructor();
+}
+
+declare class RenderText extends RenderNode {
+    readonly nodeType: RenderNodeType;
+    readonly nodeName: string;
+    constructor();
+    getDisplayName(): string;
+    /**
+     * Measure the dimensions of the text associated
+     * callback for css-layout
+     * @param: width - input width extents
+     * @param: widthMeasureMode - mode to constrain width CSS_MEASURE_MODE_EXACTLY, CSS_MEASURE_MODE_UNDEFINED
+     * @param: height - input height extents
+     * @param: heightMeasureMode - mode to constrain height CSS_MEASURE_MODE_EXACTLY, CSS_MEASURE_MODE_UNDEFINED
+     * @return: object containing measured width and height
+     */
+    measure(width: number, widthMeasureMode: number, height: number, heightMeasureMode: number): {
+        width: number;
+        height: number;
+    };
+    getTextWrapStyle(): any;
+    static measureText: _andrew_l_toolkit.WithCacheResult<(text: string) => {
+        width: number;
+        height: number;
+    }>;
+    renderToLayer(layer: Layer): void;
+    computeStyles(): void;
+}
+
+declare const Render: Readonly<{
+    readonly Flow: typeof RenderFlow;
+    readonly Block: typeof RenderBlock;
+    readonly Inline: typeof RenderInline;
+    readonly RenderText: typeof RenderText;
+    readonly Type: typeof RenderNodeType;
+}>;
+
+declare function useContainerSize(target: MaybeRefOrGetter<DOMElement | null>): {
+    width: vue.Ref<number, number>;
+    height: vue.Ref<number, number>;
+};
+
+declare function useDOMElement(): ShallowRef<DOMElement | null>;
+
+declare function useEventListener(target: MaybeRefOrGetter<DOMNode | null>, eventName: string, listener: AnyFunction): Fn;
+
+export { Box, type BoxProps, DOM, DOMComment, DOMDocument, DOMElement, DOMNode, DOMNodeType, DOMText, NewLine, type NewLineProps, ProgressBar, type ProgressBarProps, Render, Text, type TextProps, createApp, createContainer, useContainerSize, useDOMElement, useEventListener };