@nan0web/ui 1.12.3 → 3.1.1

package/types/App/Core/Widget.d.ts

@@ -1,39 +0,0 @@
-/** @typedef {import("./UI.js").ComponentFn} ComponentFn */
-/**
- * Abstract Widget class.
- * Widget is a view with ability to input data in a specific format.
- * Input and output data are typed classes.
- */
-export default class Widget extends EventProcessor {
-    /**
-     * Creates a new Widget instance.
-     * @param {View} [view] - View instance (default: new View())
-     */
-    constructor(view?: View);
-    /** @type {View} The view associated with this widget */
-    view: View;
-    /**
-     * Ask user for input data of specific class.
-     * @param {UiMessage} input - instance of UiMessage or similar
-     * @returns {Promise<UiMessage | null>} instance of UiMessage or null
-     */
-    ask(input: UiMessage): Promise<UiMessage | null>;
-    /**
-     * @param {AsyncGenerator<StreamEntry>} stream
-     * @returns {Promise<void>}
-     */
-    read(stream: AsyncGenerator<StreamEntry>): Promise<void>;
-    /**
-     * Render output data using a view function.
-     * @param {Function|string} viewFnOrName - View function or registered view name
-     * @param {object} outputData - Typed output data instance
-     * @returns {any} Rendered output
-     * @throws {Error} If view component is not found when using string name
-     */
-    render(viewFnOrName: Function | string, outputData: object): any;
-}
-export type ComponentFn = import("./UI.js").ComponentFn;
-import EventProcessor from '@nan0web/event/oop';
-import View from '../../View/View.js';
-import { UiMessage } from '../../core/index.js';
-import { StreamEntry } from '@nan0web/db';

package/types/App/Core/index.d.ts

@@ -1,10 +0,0 @@
-declare namespace _default {
-    export { CoreApp as App };
-    export { UI };
-    export { Widget };
-}
-export default _default;
-import CoreApp from './CoreApp.js';
-import UI from './UI.js';
-import Widget from './Widget.js';
-export { CoreApp, UI };

package/types/App/Scenario.d.ts

@@ -1,26 +0,0 @@
-/** @typedef {import("./Core/CoreApp.js").default} CoreApp */
-/**
- * Abstract Scenario class to test app logic.
- * Scenarios run input commands and verify output.
- */
-export default class Scenario {
-    /**
-     * Creates a new Scenario instance.
-     * @param {CoreApp} app - App instance to run scenarios against
-     * @param {UI} ui - User interface
-     * @throws {TypeError} If app is not an App.Core.App instance
-     */
-    constructor(app: CoreApp, ui: UI);
-    /** @type {CoreApp} The app to run scenarios against */
-    app: CoreApp;
-    ui: UI;
-    /**
-     * Run scenario with input commands and expected output.
-     * @param {Array<any[]>} inputCommands - Array of command arrays
-     * @param {Array<any>} expectedOutputs - Expected outputs for each command
-     * @returns {Promise<boolean>} True if all outputs match expected
-     */
-    run(inputCommands: Array<any[]>, expectedOutputs: Array<any>): Promise<boolean>;
-}
-export type CoreApp = import("./Core/CoreApp.js").default;
-import UI from './Core/UI.js';

package/types/App/User/Command/Message.d.ts

@@ -1,2 +0,0 @@
-export default UiMessage;
-import UiMessage from '../../../core/Message/Message.js';

package/types/App/User/Command/index.d.ts

@@ -1,3 +0,0 @@
-export { CommandMessage };
-export default CommandMessage;
-import CommandMessage from './Message.js';

package/types/App/User/UserApp.d.ts

@@ -1,41 +0,0 @@
-/**
- * UserApp requires user name and shows Welcome view.
- * If user.name is provided in command input, ignores user input.
- * User can change user data to see another Welcome view.
- */
-export default class UserApp extends CoreApp {
-    /**
-     * Creates a new UserApp instance.
-     * @param {Partial<CoreApp>} [props={}] - UserApp properties
-     */
-    constructor(props?: Partial<CoreApp>);
-    /**
-     * Handle deps command with async generator for stream processing.
-     * @param {DepsCommand} cmd - Command message with deps parameters
-     * @param {UserUI} ui - UI instance
-     * @returns {Promise<Object>} Command output
-     */
-    handleDeps(cmd: DepsCommand, ui: UserUI): Promise<any>;
-    /**
-     * Set user data from params.
-     * @param {UserAppCommandMessage} cmd - Command message with user data
-     * @param {UserUI} ui - UI instance
-     * @returns {Promise<{ message: string }>} Welcome message
-     */
-    setUser(cmd: UserAppCommandMessage, ui: UserUI): Promise<{
-        message: string;
-    }>;
-    /**
-     * Show welcome message for current user.
-     * @param {UserAppCommandMessage} cmd - Command message
-     * @param {UserUI} ui - UI instance
-     * @returns {Promise<string[][]>} Welcome view output
-     */
-    welcome(cmd: UserAppCommandMessage, ui: UserUI): Promise<string[][]>;
-    user: User | undefined;
-}
-import CoreApp from '../Core/CoreApp.js';
-import DepsCommand from './Command/Message.js';
-import UserUI from './UserUI.js';
-import UserAppCommandMessage from './Command/Message.js';
-import User from '../../Model/User/User.js';

package/types/App/User/UserUI.d.ts

@@ -1,9 +0,0 @@
-declare const UserUI_base: typeof import("../Core/UI.js").default;
-/**
- * UserUI connects UserApp and View.
- * It asks user for name if not provided in command input.
- * Allows user to change user data to see another Welcome view.
- */
-export default class UserUI extends UserUI_base {
-}
-export {};

package/types/App/User/index.d.ts

@@ -1,8 +0,0 @@
-declare namespace _default {
-    export { UserApp as App };
-    export { UserUI as UI };
-}
-export default _default;
-import UserApp from './UserApp.js';
-import UserUI from './UserUI.js';
-export { UserApp, UserUI };

package/types/App/index.d.ts

@@ -1,12 +0,0 @@
-declare namespace _default {
-    export { Core };
-    export { User };
-    export { Scenario };
-    export { UI };
-}
-export default _default;
-import Core from './Core/index.js';
-import User from './User/index.js';
-import Scenario from './Scenario.js';
-import UI from './Core/UI.js';
-export { Core, User, Scenario, UI };

package/types/Component/Process/Input.d.ts

@@ -1,48 +0,0 @@
-export default ProcessInput;
-/**
- * Represents input data for the Process component.
- * Holds configuration for rendering a progress bar.
- */
-declare class ProcessInput {
-    /**
-     * Creates a ProcessInput instance from the given props.
-     * @param {ProcessInput|object} props - The properties to create from
-     * @returns {ProcessInput} A ProcessInput instance
-     */
-    static from(props?: ProcessInput | object): ProcessInput;
-    /**
-     * Creates a new ProcessInput instance.
-     * @param {object} props - Process input properties
-     * @param {string} [props.name="NaN•Coding"] - Process name
-     * @param {number} [props.i=0] - Current progress index
-     * @param {number} [props.top=9] - Top limit for progress normalization
-     * @param {number} [props.width=9] - Width of the progress bar
-     * @param {string} [props.space='•'] - Character for empty space
-     * @param {string} [props.char='*'] - Character for filled progress
-     */
-    constructor(props?: {
-        name?: string | undefined;
-        i?: number | undefined;
-        top?: number | undefined;
-        width?: number | undefined;
-        space?: string | undefined;
-        char?: string | undefined;
-    });
-    /** @type {string} Process name to display */
-    name: string;
-    /** @type {number} Current progress index */
-    i: number;
-    /** @type {number} Top limit for progress normalization */
-    top: number;
-    /** @type {number} Width of the progress bar */
-    width: number;
-    /** @type {string} Character to use for empty space */
-    space: string;
-    /** @type {string} Character to use for filled progress */
-    char: string;
-    /**
-     * Converts the input to a string representation.
-     * @returns {string} String representation of the ProcessInput
-     */
-    toString(): string;
-}

package/types/Component/Process/Process.d.ts

@@ -1,13 +0,0 @@
-export default Process;
-/**
- * Renders a progress bar based on input configuration.
- * @this {View}
- * @param {ProcessInput|object} props - Process component properties
- * @returns {string[][]} Rendered progress bar as array of strings
- */
-declare function Process(this: View, props?: ProcessInput | object): string[][];
-declare namespace Process {
-    export { ProcessInput as Input };
-}
-import ProcessInput from './Input.js';
-import View from '../../View/View.js';

package/types/Component/Process/index.d.ts

@@ -1,4 +0,0 @@
-export default Process;
-export { ProcessInput };
-import Process from './Process.js';
-import ProcessInput from './Input.js';

package/types/Component/Welcome/Input.d.ts

@@ -1,34 +0,0 @@
-export default WelcomeInput;
-/**
- * Represents input data for the Welcome component.
- * Holds user data to display in the welcome message.
- */
-declare class WelcomeInput {
-    /**
-     * Creates a WelcomeInput instance from the given props.
-     * @param {WelcomeInput|object} props - The properties to create from
-     * @returns {WelcomeInput} A WelcomeInput instance
-     */
-    static from(props?: WelcomeInput | object): WelcomeInput;
-    /**
-     * Creates a new WelcomeInput instance.
-     * @param {object} props - Welcome input properties
-     * @param {User|object} [props.user=new User()] - User data
-     */
-    constructor(props?: {
-        user?: User | object;
-    });
-    /** @type {User} User data for welcome message */
-    user: User;
-    /**
-     * Checks if the input is empty (no user data).
-     * @returns {boolean} True if user data is empty, false otherwise
-     */
-    get empty(): boolean;
-    /**
-     * Converts the input to a string representation.
-     * @returns {string} String representation of the WelcomeInput
-     */
-    toString(): string;
-}
-import { User } from '../../Model/index.js';

package/types/Component/Welcome/Welcome.d.ts

@@ -1,13 +0,0 @@
-export default Welcome;
-/**
- * Renders a welcome message for a user.
- * @param {WelcomeInput|object} props - Welcome component properties
- * @returns {string[][]} Rendered welcome message as array of strings
- * @throws {Error} If no user data is provided
- */
-declare function Welcome(props?: WelcomeInput | object): string[][];
-declare namespace Welcome {
-    export { WelcomeInput as Input };
-    export function ask(): Promise<string>;
-}
-import WelcomeInput from './Input.js';

package/types/Component/Welcome/index.d.ts

@@ -1,4 +0,0 @@
-export default Welcome;
-export { WelcomeInput };
-import Welcome from './Welcome.js';
-import WelcomeInput from './Input.js';

package/types/Frame/Frame.d.ts

@@ -1,186 +0,0 @@
-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): 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): 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): 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;
-    });
-    /**
-     * @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;
-    }): 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

@@ -1,77 +0,0 @@
-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/StdIn.d.ts

@@ -1,62 +0,0 @@
-/**
- * Handles standard input stream with message buffering.
- */
-export default 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 {UiMessage[]} [props.stream=[]] - Initial input stream
-     */
-    constructor(props?: {
-        processor?: Processor | undefined;
-        stream?: UiMessage[] | undefined;
-    });
-    /** @type {Processor} Input processor */
-    processor: Processor;
-    /** @type {UiMessage[]} Input message buffer */
-    stream: UiMessage[];
-    /**
-     * 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<UiMessage>} Next input message
-     */
-    read(): Promise<UiMessage>;
-    /**
-     * 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 UiMessage instance.
-     * @param {UiMessage | string[] | any} message - Message to decode
-     * @returns {UiMessage} Decoded input message
-     */
-    decode(message: UiMessage | string[] | any): UiMessage;
-}
-import EventProcessor from '@nan0web/event/oop';
-declare class Processor extends EventProcessor {
-}
-import { UiMessage } from './core/index.js';
-export {};

package/types/StdOut.d.ts

@@ -1,52 +0,0 @@
-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';