@nan0web/ui 1.0.0

package/types/Frame/Frame.d.ts

@@ -0,0 +1,186 @@
+export class FrameRenderMethod {
+    static APPEND: string;
+    static REPLACE: string;
+    static VISIBLE: string;
+}
+/**
+ * @link https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797 - ANSI escape codes
+ */
+export default class Frame {
+    /** @type {typeof FrameRenderMethod} */
+    static RenderMethod: typeof FrameRenderMethod;
+    static Props: typeof FrameProps;
+    /** @type {string} End of line */
+    static EOL: string;
+    /** @type {string} Beginning of line */
+    static BOL: string;
+    /** @type {string} Beginning of frame */
+    static BOF: string;
+    /** @type {string} Hide cursor */
+    static HIDE_CURSOR: string;
+    /** @type {string} Show cursor */
+    static SHOW_CURSOR: string;
+    /** @type {string} Tab */
+    static TAB: string;
+    /** @type {string} Bold */
+    static BOLD: string;
+    /** @type {string} Italic */
+    static ITALIC: string;
+    /** @type {string} Underline */
+    static UNDERLINE: string;
+    /** @type {string} Strikethrough */
+    static STRIKETHROUGH: string;
+    /** @type {string} Reset */
+    static RESET: string;
+    /** @type {string} Clear line */
+    static CLEAR_LINE: string;
+    /**
+     * Check if a value can be used to create a Frame instance.
+     * @param {*} value - Value to check.
+     * @returns {boolean} True if the value is valid for Frame creation.
+     */
+    static is(value: any): boolean;
+    /**
+     * Create a Frame instance from input.
+     * @param {*} input - Input value to convert.
+     * @returns {Frame} A new Frame instance.
+     */
+    static from(input: any): Frame;
+    /**
+     * Create a function to space columns based on options.
+     * @param {object} options - Spacing options.
+     * @param {number[]} [options.cols=[]] - Widths of the columns.
+     * @param {number} [options.padding=1] - Padding between columns.
+     * @param {string[]} [options.aligns=[]] - Alignment for each column ('l' or 'r').
+     * @returns {Function} Function that spaces a row.
+     */
+    static spaces(options?: {
+        cols?: number[] | undefined;
+        padding?: number | undefined;
+        aligns?: string[] | undefined;
+    }): Function;
+    /**
+     *
+     * @param {Array} arr
+     * @returns {(v) => number[]}
+     */
+    static weight(arr: any[]): (v: any) => number[];
+    /**
+     *
+     * @param {object} options
+     * @param {Function} [options.fn=(fn = v => v)] - Function to calculate weight.
+     * @param {number[]} [options.cols=[]] - Widths of the columns.
+     * @param {number} [options.padding=1] - The padding between columns.
+     * @param {string[]} [options.aligns=[]] - The column aligns: l, r
+     * @returns {(arr: []) => string[][]}
+     */
+    static table(options?: {
+        fn?: Function | undefined;
+        cols?: number[] | undefined;
+        padding?: number | undefined;
+        aligns?: string[] | undefined;
+    }): (arr: []) => string[][];
+    /**
+     * Move cursor up by specified lines.
+     * @param {number} [lines=1] - Number of lines to move up.
+     * @returns {string} ANSI escape code for cursor movement.
+     */
+    static cursorUp(lines?: number | undefined): string;
+    /**
+     * Move cursor down by specified lines.
+     * @param {number} [lines=1] - Number of lines to move down.
+     * @returns {string} ANSI escape code for cursor movement.
+     */
+    static cursorDown(lines?: number | undefined): string;
+    /**
+     * Clear the current line.
+     * @param {string} [str="\r"] - String to append after clearing.
+     * @returns {string} ANSI escape code for line clearing followed by the string.
+     */
+    static clearLine(str?: string | undefined): string;
+    /**
+     * Clear the entire screen.
+     * @returns {string} ANSI escape codes for screen clearing.
+     */
+    static clearScreen(): string;
+    /**
+     * @param {object} [input]
+     * @param {string[]|string[][]} [input.value]
+     * @param {number} [input.width]
+     * @param {number} [input.height]
+     * @param {string} [input.imprint]
+     * @param {string} [input.renderMethod]
+     * @param {FrameProps} [input.defaultProps]
+     */
+    constructor(input?: {
+        value?: string[] | string[][] | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        imprint?: string | undefined;
+        renderMethod?: string | undefined;
+        defaultProps?: FrameProps | undefined;
+    } | undefined);
+    /**
+     * @example
+     * ```js
+     * new Frame([
+     * 	["Hello", "World"],
+     * 	[["Hello", { color: "red", bgColor: "#009" }], "World"],
+     * 	["<b i fg=#900>Hello</b>", "<i>World</i>"],
+     * ])
+     * ```
+     * @type {string[][]|any[][]}
+     */
+    value: string[][] | any[][];
+    /** @type {FrameProps} */
+    defaultProps: FrameProps;
+    /** @type {string} */
+    imprint: string;
+    /** @type {number} */
+    width: number;
+    /** @type {number} */
+    height: number;
+    /** @type {string} */
+    renderMethod: string;
+    /**
+     * Get whether the frame is empty.
+     * @returns {boolean} True if the frame has no content.
+     */
+    get empty(): boolean;
+    /**
+     * Calculate the visual width of a string.
+     * @param {string} str
+     * @returns {number} The visual width of the string.
+     */
+    lengthOf(str: string): number;
+    /**
+     * Render the frame into a string representation.
+     * @param {object} [options]
+     * @param {string} [options.method] - Render method to use.
+     * @param {FrameProps} [options.props] - Properties to apply during rendering.
+     * @returns {string} The rendered frame as a string.
+     */
+    render(options?: {
+        method?: string | undefined;
+        props?: FrameProps | undefined;
+    } | undefined): string;
+    /**
+     * Convert the frame to its string representation.
+     * @returns {string} The frame's imprint.
+     */
+    toString(): string;
+    /**
+     * Transform each cell in the frame using a function.
+     * @param {Function} fn - Function to apply to each cell.
+     * @returns {Frame} A new Frame with transformed values.
+     */
+    transform(fn: Function): Frame;
+    /**
+     * Set the window size for the frame.
+     * @param {number} width - The width of the window.
+     * @param {number} height - The height of the window.
+     */
+    setWindowSize(width: number, height: number): void;
+    #private;
+}
+import FrameProps from "./Props.js";

package/types/Frame/Props.d.ts

@@ -0,0 +1,77 @@
+export default FrameProps;
+/**
+ * Represents default styling properties for Frame rendering.
+ * Every tag must be a separate value in the array of rows/columns.
+ * If you want to apply the same props to multiple values, you can use an array of values.
+ * If you want to apply different props to multiple values, you can use an object with the props.
+ * If you want to apply props to a single value, you can use a string with the props in XML format.
+ * Parser checks every atom for its beginning and end and if it's a tag, it applies the props to the value.
+ *
+ * @example
+ * const defaultProps = new FrameProps({
+ * 	color: "red",
+ * 	bgColor: "blue",
+ * 	bold: true,
+ * 	italic: true,
+ * 	underline: true,
+ * 	strikethrough: true,
+ * })
+ * or by aliases:
+ * const defaultProps = new FrameProps({
+ * 	fg: "red",
+ * 	bg: "blue",
+ * 	b: true,
+ * 	i: true,
+ * 	u: true,
+ * 	s: true,
+ * })
+ * from an array of strings:
+ * const rows = [
+ * 	["Hello", "World"],
+ * 	["<fg=red>Hello</>", "<bg=blue>World</>"],
+ * 	["<b>Hello</b>", "<i>World</i>"],
+ * 	["<u>Hello</u>", "<s>World</s>"],
+ * 	["<b fg=red>Hello</b>", "<i bg=blue>World</i>"],
+ * 	["<b i>Hello</b>", "<i b>World</i>"],
+ * 	["<b i s>Some</b>", ["thing", {b: true, i: true, s: true}]],
+ * 	[["Hello", "World", {b: true}]],
+ * ]
+ * const defaultProps = new FrameProps(rows)
+ */
+declare class FrameProps extends ObjectWithAlias {
+    /**
+     * Property aliases for shorthand notation.
+     * @type {Record<string, string>}
+     */
+    static ALIAS: Record<string, string>;
+    /**
+     * @param {object} props - Frame properties
+     * @param {string} [props.color=""] - Text color
+     * @param {string} [props.bgColor=""] - Background color
+     * @param {boolean} [props.bold=false] - Bold text flag
+     * @param {boolean} [props.italic=false] - Italic text flag
+     * @param {boolean} [props.underline=false] - Underline text flag
+     * @param {boolean} [props.strikethrough=false] - Strikethrough text flag
+     */
+    constructor(props?: {
+        color?: string | undefined;
+        bgColor?: string | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        underline?: boolean | undefined;
+        strikethrough?: boolean | undefined;
+    });
+    /** @type {string} Text color */
+    color: string;
+    /** @type {string} Background color */
+    bgColor: string;
+    /** @type {boolean} Bold text flag */
+    bold: boolean;
+    /** @type {boolean} Italic text flag */
+    italic: boolean;
+    /** @type {boolean} Underline text flag */
+    underline: boolean;
+    /** @type {boolean} Strikethrough text flag */
+    strikethrough: boolean;
+}
+import { ObjectWithAlias } from "@nan0web/types";

package/types/Locale.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Handles locale-specific formatting for different data types.
+ */
+export default class Locale {
+    /**
+     * @param {any} input
+     * @returns {Locale}
+     */
+    static from(input: any): Locale;
+    /**
+     * Creates a new Locale instance.
+     * @param {object} props - Locale properties or all locale string
+     * @param {string} [props.lang=""] - Language locale
+     * @param {string} [props.collate=""] - Collation locale
+     * @param {string} [props.ctype=""] - Character type locale
+     * @param {string} [props.messages=""] - Messages locale
+     * @param {string} [props.monetary=""] - Monetary locale
+     * @param {string} [props.numeric=""] - Numeric locale
+     * @param {string} [props.time=""] - Time locale
+     * @param {string} [props.all="uk_UA.UTF-8"] - General locale fallback
+     */
+    constructor(props?: {
+        lang?: string | undefined;
+        collate?: string | undefined;
+        ctype?: string | undefined;
+        messages?: string | undefined;
+        monetary?: string | undefined;
+        numeric?: string | undefined;
+        time?: string | undefined;
+        all?: string | undefined;
+    });
+    /** @type {string} Language locale */
+    lang: string;
+    /** @type {string} Collation locale */
+    collate: string;
+    /** @type {string} Character type locale */
+    ctype: string;
+    /** @type {string} Messages locale */
+    messages: string;
+    /** @type {string} Monetary locale */
+    monetary: string;
+    /** @type {string} Numeric locale */
+    numeric: string;
+    /** @type {string} Time locale */
+    time: string;
+    /** @type {string} General locale fallback */
+    all: string;
+    /**
+     * Formats values according to locale settings.
+     * @param {Function} type - Type constructor (Number, String, etc.)
+     * @param {object} options - Formatting options
+     * @returns {Function|null} Formatting function or null if unsupported type
+     */
+    format(type: Function, options: object): Function | null;
+}

package/types/Model/User/User.d.ts

@@ -0,0 +1,36 @@
+export default User;
+/**
+ * Represents a user with name and email properties.
+ */
+declare class User {
+    /**
+     * Creates a User instance from the given props.
+     * @param {User|object|string} props - The properties to create from
+     * @returns {User} A User instance
+     */
+    static from(props: User | object | string): User;
+    /**
+     * Creates a new User instance.
+     * @param {object} props - User properties or name string
+     * @param {string} [props.name=""] - User name
+     * @param {string} [props.email=""] - User email
+     */
+    constructor(props?: {
+        name?: string | undefined;
+        email?: string | undefined;
+    });
+    /** @type {string} User name */
+    name: string;
+    /** @type {string} User email */
+    email: string;
+    /**
+     * Checks if user data is empty (no name and no email).
+     * @returns {boolean} True if both name and email are empty, false otherwise
+     */
+    get empty(): boolean;
+    /**
+     * Converts user to string representation.
+     * @returns {string} User name and email (if exists)
+     */
+    toString(): string;
+}

package/types/Model/index.d.ts

@@ -0,0 +1,6 @@
+export { User };
+declare namespace _default {
+    export { User };
+}
+export default _default;
+import User from "./User/User.js";

package/types/StdIn.d.ts

@@ -0,0 +1,62 @@
+export default StdIn;
+/**
+ * Handles standard input stream with message buffering.
+ */
+declare class StdIn extends EventProcessor {
+    /** @type {number} Read interval in milliseconds */
+    static READ_INTERVAL: number;
+    /** @type {string[]} Messages to ignore */
+    static IGNORE_MESSAGES: string[];
+    /**
+     * Creates a StdIn instance from the given input.
+     * @param {StdIn|object} input - The input to create from
+     * @returns {StdIn} A StdIn instance
+     */
+    static from(input: StdIn | object): StdIn;
+    /**
+     * Creates a new StdIn instance.
+     * @param {object} props - StdIn properties
+     * @param {Processor} [props.processor] - Input processor
+     * @param {InputMessage[]} [props.stream=[]] - Initial input stream
+     */
+    constructor(props?: {
+        processor?: Processor | undefined;
+        stream?: InputMessage[] | undefined;
+    });
+    /** @type {InputMessage[]} Input message buffer */
+    stream: InputMessage[];
+    /** @type {Processor} Input processor */
+    processor: Processor;
+    /**
+     * Checks if there are messages waiting in the input stream.
+     * @returns {boolean} True if waiting messages, false otherwise
+     */
+    get waiting(): boolean;
+    /**
+     * Checks if the input stream has ended (no messages left).
+     * @returns {boolean} True if no messages left, false otherwise
+     */
+    get ended(): boolean;
+    /**
+     * Reads a message from the input stream.
+     * Waits until messages are available if stream is empty.
+     * @returns {Promise<InputMessage>} Next input message
+     */
+    read(): Promise<InputMessage>;
+    /**
+     * Writes a message to the input stream.
+     * @param {string} message - Message to write
+     * @returns {boolean} True if message accepted, False if ignored
+     */
+    write(message: string): boolean;
+    /**
+     * Decodes a message into an InputMessage instance.
+     * @param {InputMessage | string[] | any} message - Message to decode
+     * @returns {InputMessage} Decoded input message
+     */
+    decode(message: InputMessage | string[] | any): InputMessage;
+}
+import EventProcessor from "@nan0web/event/oop";
+import InputMessage from "./core/Message/InputMessage.js";
+declare class Processor extends EventProcessor {
+}

package/types/StdOut.d.ts

@@ -0,0 +1,52 @@
+export default StdOut;
+/**
+ * Handles standard output stream with formatting capabilities.
+ */
+declare class StdOut extends EventProcessor {
+    /** @type {string} End of line character */
+    static EOL: string;
+    /** @type {string} Beginning of line character */
+    static BOL: string;
+    /** @type {string} Reset formatting escape code */
+    static RESET: string;
+    /** @type {string} Clear screen escape code */
+    static CLEAR: string;
+    /** @type {object} Color escape codes */
+    static COLORS: object;
+    /** @type {Record<string, string>} Style escape codes */
+    static STYLES: Record<string, string>;
+    /**
+     * Creates a new StdOut instance.
+     * @param {object} props - StdOut properties
+     * @param {any} [props.processor] - Output processor
+     * @param {string[]} [props.stream=[]] - Initial output stream
+     * @param {number[]} [props.windowSize=[144, 33]] - Window size [width, height]
+     */
+    constructor(props?: {
+        processor?: any;
+        stream?: string[] | undefined;
+        windowSize?: number[] | undefined;
+    });
+    /**
+     * @todo define go top by rows constants.
+     */
+    /** @type {string[]} Output stream buffer */
+    stream: string[];
+    /** @type {number[]} Window size [width, height] */
+    windowSize: number[];
+    /** @type {any} Output processor */
+    processor: any;
+    /**
+     * Writes output to the output stream.
+     * Must be overwritten by other apps.
+     * @param {any} output - Output to write
+     * @param {Function} onError - Error handler callback
+     */
+    write(output: any, onError?: Function): void;
+    /**
+     * Gets the window size.
+     * @returns {number[]} Window size [width, height]
+     */
+    getWindowSize(): number[];
+}
+import EventProcessor from "@nan0web/event/oop";

package/types/View/RenderOptions.d.ts

@@ -0,0 +1,29 @@
+export default RenderOptions;
+declare class RenderOptions {
+    static DEFAULTS: {
+        resizeToView: boolean;
+        translateFrame: boolean;
+        render: boolean;
+        renderMethod: string;
+    };
+    static from(props?: {}): RenderOptions;
+    constructor(props?: {});
+    /** @type {boolean} [false] */
+    resizeToView: boolean;
+    /** @type {boolean} [false] */
+    translateFrame: boolean;
+    /** @type {boolean} [true] */
+    render: boolean;
+    /** @type {string} */
+    renderMethod: string;
+    /** @type {number} */
+    width: number;
+    /** @type {number} */
+    height: number;
+    get DEFAULTS(): {
+        resizeToView: boolean;
+        translateFrame: boolean;
+        render: boolean;
+        renderMethod: string;
+    };
+}

package/types/View/View.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @typedef {Object} ComponentFn
+ * @property {string} name
+ * @property {(input: InputMessage) => Promise<any>} ask
+ * @property {Function} bind
+ */
+export default class View {
+    /** @type {typeof RenderOptions} */
+    static RenderOptions: typeof RenderOptions;
+    /** @type {typeof FrameRenderMethod} */
+    static RenderMethod: typeof FrameRenderMethod;
+    /**
+     * @param {Frame} frame
+     * @param {RenderOptions} [options]
+     * @returns {Frame}
+     */
+    static fixFrame(frame: Frame, options?: RenderOptions | undefined): Frame;
+    /**
+     * @param {object} [input]
+     * @param {StdIn} [input.stdin]
+     * @param {StdOut} [input.stdout]
+     * @param {number} [input.startedAt]
+     * @param {Frame} [input.frame]
+     * @param {Locale} [input.locale]
+     * @param {Map} [input.vocab]
+     * @param {number[]} [input.windowSize]
+     * @param {Map<string, ComponentFn>} [input.components]
+     * @param {string} [input.renderMethod]
+     */
+    constructor(input?: {
+        stdin?: StdIn | undefined;
+        stdout?: StdOut | undefined;
+        startedAt?: number | undefined;
+        frame?: Frame | undefined;
+        locale?: Locale | undefined;
+        vocab?: Map<any, any> | undefined;
+        windowSize?: number[] | undefined;
+        components?: Map<string, ComponentFn> | undefined;
+        renderMethod?: string | undefined;
+    } | undefined);
+    /** @type {StdIn} */
+    stdin: StdIn;
+    /** @type {StdOut} */
+    stdout: StdOut;
+    /** @type {number} */
+    startedAt: number;
+    /** @type {Frame} */
+    frame: Frame;
+    /** @type {Locale} */
+    locale: Locale;
+    /** @type {Map} */
+    vocab: Map<any, any>;
+    /** @type {number[]} */
+    windowSize: number[];
+    /** @type {Map<string, ComponentFn>} */
+    components: Map<string, ComponentFn>;
+    /** @type {string} */
+    renderMethod: string;
+    get empty(): boolean;
+    get RenderMethod(): typeof FrameRenderMethod;
+    get RenderOptions(): typeof RenderOptions;
+    getWindowSize(): number[];
+    setWindowSize(width: any, height: any): void;
+    startTimer(): void;
+    spent(checkpoint?: number): number;
+    /**
+     * @param {boolean | number | Function | ComponentFn} [shouldRender=0]
+     * @param {RenderOptions} [options]
+     * @returns {(value: Frame|string|string[], ...args: any) => Frame}
+     */
+    render(shouldRender?: number | boolean | Function | ComponentFn | undefined, options?: RenderOptions | undefined): (value: Frame | string | string[], ...args: any) => Frame;
+    clear(shouldRender?: number): Frame;
+    progress(shouldRender?: boolean): (value: any) => Frame;
+    t(value: any): any;
+    debug(...args: any[]): Frame;
+    info(...args: any[]): Frame;
+    warn(...args: any[]): Frame;
+    error(...args: any[]): Frame;
+    /**
+     * @param {string} name
+     * @param {ComponentFn} component
+     */
+    register(name: string, component: ComponentFn): void;
+    /**
+     * @param {string} name
+     */
+    unregister(name: string): void;
+    /**
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has(name: string): boolean;
+    /**
+     * @param {string} name
+     * @returns {ComponentFn | undefined}
+     */
+    get(name: string): ComponentFn | undefined;
+    /**
+     * @param {InputMessage} input
+     * @returns {Promise<InputMessage | null>}
+     */
+    ask(input: InputMessage): Promise<InputMessage | null>;
+}
+export type ComponentFn = {
+    name: string;
+    ask: (input: InputMessage) => Promise<any>;
+    bind: Function;
+};
+import StdIn from "../StdIn.js";
+import StdOut from "../StdOut.js";
+import Frame from "../Frame/Frame.js";
+import Locale from "../Locale.js";
+import { FrameRenderMethod } from "../Frame/Frame.js";
+import RenderOptions from "./RenderOptions.js";
+import InputMessage from "../core/Message/InputMessage.js";