@reliverse/relinka 1.1.2 → 1.1.4

package/dist-npm/components/prompts/promptTwo.d.ts

@@ -1,98 +1,26 @@
 export { isCancel } from "../../components/prompts/prompt.js";
 export type TextOptions = {
-    /**
-     * The primary message to display for the prompt.
-     */
-    message: string;
-    /**
-     * A placeholder string that is displayed in the input field when it is empty. It disappears when the user starts typing.
-     * @optional
-     */
-    placeholder?: string;
-    /**
-     * The primary message to display for the prompt.
-     * A default value for the input field.This value will be returned if the user does not enter a value.
-     * @optional
-     */
-    defaultValue?: string;
-    /**
-     * An initial value that appears in the input field. Unlike `defaultValue`, it can be edited or removed by the user.
-     * @optional
-     */
-    initialValue?: string;
-    /**
-     * A function to validate the input. If the input is not valid, this function should return a string message.
-     * The prompt will continue until a valid value is entered or the prompt is aborted.
-     * @param {string} value - The current value of the input field.
-     * @returns {string | void} A string with an error message if validation fails or `void` if the input is valid.
-     * optional
-     */
-    validate?: (value: string) => string | void;
+        message: string;
+        placeholder?: string;
+        defaultValue?: string;
+        initialValue?: string;
+        validate?: (value: string) => string | void;
 };
-/**
- * Provides text input functionality with customizable options.
- * @param {TextOptions} opts - Options to customize the text prompt. See {@link TextOptions}.
- * @returns {Promise<string | symbol>} A promise that resolves to the user input or a symbol for special cases.
- */
 export declare const text: (opts: TextOptions) => any;
 export type PasswordOptions = {
-    /**
-     * The message to be displayed above the input field.
-     */
-    message: string;
-    /**
-     * A character that masks the user's input, hiding the text they type.
-     * @optional
-     */
-    mask?: string;
-    /**
-     * A function to validate the input. Returns an error message if the input fails validation.
-     * @param {string} value - The current value of the input field.
-     * @returns {string | void} An error message if the input fails validation, or `void` if the input is valid.
-     * @optional
-     */
-    validate?: (value: string) => string | void;
+        message: string;
+        mask?: string;
+        validate?: (value: string) => string | void;
 };
-/**
- * Provides password input functionality with customizable options, including input masking.
- * @param {PasswordOptions} opts - Options to customize the password prompt. See {@link PasswordOptions}.
- * @returns {Promise<string | symbol>} A promise that resolves to the user input or a symbol for special cases.
- */
 export declare const password: (opts: PasswordOptions) => any;
 export type ConfirmOptions = {
-    /**
-     * The primary message to display for the prompt.
-     */
-    message: string;
-    /**
-     * The text to display for the active/affirmative choice.
-     * @optional
-     */
-    active?: string;
-    /**
-     * Text to display for the inactive/negative choice.
-     * @optional
-     */
-    inactive?: string;
-    /**
-     * The initial selection value.
-     * @optional
-     */
-    initialValue?: boolean;
+        message: string;
+        active?: string;
+        inactive?: string;
+        initialValue?: boolean;
 };
-/**
- * Provides a confirmation prompt with customizable options.
- * @param {ConfirmOptions} opts - Options to customize the confirmation prompt. See {@link ConfirmOptions}.
- * @returns {Promise<boolean | symbol>} A promise that resolves to the user's choice, or a symbol for special cases.
- */
 export declare const confirm: (opts: ConfirmOptions) => Promise<boolean | symbol>;
-/**
- * A generic type for option values in a select prompt, supporting both primitive and complex types.
- */
 type Primitive = Readonly<string | boolean | number>;
-/**
- * Defines the structure of an option in a select prompt.
- */
 type Option<Value> = Value extends Primitive ? {
     value: Value;
     label?: string;
@@ -102,181 +30,45 @@ type Option<Value> = Value extends Primitive ? {
     label: string;
     hint?: string;
 };
-/**
- * Options for configuring the select prompt.
- * @template Options - An array of option objects. See {@link Option}.
- * @template Value - The type of option value. See {@link Option}.
- */
 export type SelectOptions<Options extends Option<Value>[], Value> = {
-    /**
-     * The primary message to display at the prompt.
-     */
-    message: string;
-    /**
-     * The list of options from which the user can choose. See {@link Option}.
-     */
-    options: Options;
-    /**
-     * The initial value selected in the prompt. See {@link Value}.
-     * @optional
-     */
-    initialValue?: Value;
+        message: string;
+        options: Options;
+        initialValue?: Value;
 };
-/**
- * Provides a select prompt functionality where the user can choose from a list of options.
- * @param {SelectOptions<Options, Value>} opts - Options to customize the select prompt. See {@link SelectOptions}.
- * @returns {Promise<Value | Symbol>} A promise that resolves to the selected value or a symbol for special cases. See {@link Value}.
- */
 export declare const select: <Options extends Option<Value>[], Value>(opts: SelectOptions<Options, Value>) => Promise<Value | symbol>;
-/**
- * Provides a prompt that allows the user to select an option by pressing a key.
- * This is useful for scenarios where each option is associated with a specific key.
- * @param {SelectOptions<Options, Value>} opts - Configuration options for the select key prompt. See {@link SelectOptions}.
- * @returns {Promise<Value | Symbol>} A promise that resolves to the value of the selected option, or a symbol for special cases such as abort. See {@link Value}.
- */
 export declare const selectKey: <Options extends Option<Value>[], Value extends string>(opts: SelectOptions<Options, Value>) => Promise<Value | symbol>;
 export type MultiSelectOptions<Options extends Option<Value>[], Value> = {
-    /**
-     * The primary message to be displayed above the multi-select list.
-     */
-    message: string;
-    /**
-     * The list of options from which users can select multiple items. See {@link Option}.
-     */
-    options: Options;
-    /**
-     * An array of values representing the options initially selected in the prompt. See {@link Value}.
-     * @optional
-     */
-    initialValues?: Value[];
-    /**
-     * Specifies whether at least one selection is required before submitting.
-     * @optional
-     */
-    required?: boolean;
-    /**
-     * The value of the option on which the cursor is initially placed when the command prompt opens. See {@link Value}.
-     * @optional
-     */
-    cursorAt?: Value;
+        message: string;
+        options: Options;
+        initialValues?: Value[];
+        required?: boolean;
+        cursorAt?: Value;
 };
-/**
- * Provides multi-select prompt functionality where the user can select multiple options from a list.
- * @param {MultiSelectOptions<Options, Value>} opts - Options to customize the multi-select prompt. See {@link MultiSelectOptions}.
- * @returns {Promise<Value[] | Symbol>} A promise that resolves to an array of selected values, or a symbol for special cases.
- */
 export declare const multiselect: <Options extends Option<Value>[], Value>(opts: MultiSelectOptions<Options, Value>) => Promise<Value[] | symbol>;
 export type GroupMultiSelectOptions<Options extends Option<Value>[], Value> = {
-    /**
-     * The primary message to be displayed above the group multi-select list.
-     */
-    message: string;
-    /**
-     * An object containing groups of options. Each key represents a group name,
-     * and the associated value is an array of options within that group. See {@link Option}.
-     */
-    options: Record<string, Options>;
-    /**
-     * An array of values representing the initially selected options across all groups. See {@link Value}.
-     * @optional
-     */
-    initialValues?: Value[];
-    /**
-     * Specifies whether at least one selection is required before submission is allowed.
-     * @optional
-     */
-    required?: boolean;
-    /**
-     * The value of the option on which the cursor will initially appear when the command prompt opens. See {@link Value}.
-     * @optional
-     */
-    cursorAt?: Value;
+        message: string;
+        options: Record<string, Options>;
+        initialValues?: Value[];
+        required?: boolean;
+        cursorAt?: Value;
 };
 export declare const groupMultiselect: <Options extends Option<Value>[], Value>(opts: GroupMultiSelectOptions<Options, Value>) => Promise<Value[] | symbol>;
-/**
- * Displays a formatted note in the console, with an optional title. The note is visually distinguished
- * from regular console output with ANSI color codes and styles to make it stand out. The function calculates
- * the length of the longest line to ensure the note is properly aligned and framed.
- *
- * @param {string} [message=""] - The main text of the note. Supports multiline strings.
- * @param {string} [title=""] - An optional title for the note. If provided, it'll be displayed above the message.
- */
 export declare const note: (message?: string, title?: string) => void;
-/**
- * Prints an abort message to the console. This is typically used to indicate
- * that a process or operation has been cancelled. The message is colored for
- * for emphasis and visual differentiation.
- *
- * @param {string} [message=""] - The cancellation message to display. This parameter
- * is optional; if omitted, the default styling will be used without a specific message.
- */
 export declare const cancel: (message?: string) => void;
-/**
- * Prints an introductory message to the console. This function is used to
- * Display a title or short message at the beginning of a script or application.
- * framed by a specified bar character for visual distinction.
- *
- * @param {string} [title=""] - The title or message to display. This parameter is optional; if omitted, only the framing bar will be printed.
- */
 export declare const intro: (title?: string) => void;
-/**
- * Prints a closing message to the console. Similar to the `intro` function,
- * `outro' is designed to indicate the end of a script or application execution
- * with a framed message for clear visual separation from the rest of the console output.
- *
- * @param {string} [message=""] - The final message to display. This parameter is optional; if omitted, only the border will be printed.
- */
 export declare const outro: (message?: string) => void;
 export type LogMessageOptions = {
-    /**
-     * A custom icon to be placed in front of the log message. This allows visual differentiation
-     * log messages based on their importance or category (e.g. info, error).
-     * @optional
-     */
-    symbol?: string;
+        symbol?: string;
 };
-/**
- * Logs a message to the console, with support for different types of messages (info, success, warning, error).
- */
 export declare const log: {
-    /**
-     * Logs an message, prefixed with a gray bar.
-     * @param {string} message - The message to log.
-     * @param {LogMessageOptions} [opts] - Optional settings for the log message. See {@link LogMessageOptions}.
-     */
-    message: (message?: string, { symbol }?: LogMessageOptions) => void;
-    /**
-     * Logs an information message, prefixed with a blue info icon.
-     * @param {string} message - The message to log.
-     */
-    info: (message: string) => void;
-    /**
-     * Logs a success message, preceded by a green check symbol.
-     * @param {string} message - The message to log.
-     */
-    success: (message: string) => void;
-    /**
-     * Logs a step message, typically used to indicate a step in a process, preceded by a green submit symbol.
-     * @param {string} message - The message to log.
-     */
-    step: (message: string) => void;
-    /**
-     * Logs a warning message, preceded by a yellow warning icon.
-     * @param {string} message - The message to log.
-     */
-    warn: (message: string) => void;
-    /** alias for `log.warn()`. See {@link log.warn}. */
-    warning: (message: string) => void;
-    /**
-     * Logs an error message, preceded by a red error icon.
-     * @param {string} message - The message to log.
-     */
-    error: (message: string) => void;
+        message: (message?: string, { symbol }?: LogMessageOptions) => void;
+        info: (message: string) => void;
+        success: (message: string) => void;
+        step: (message: string) => void;
+        warn: (message: string) => void;
+        warning: (message: string) => void;
+        error: (message: string) => void;
 };
-/**
- * Displays an animated spinner with a message, with functionality to start and stop the animation.
- * @returns an object with `start` and `stop` methods to control the spinner.
- */
 export declare const spinner: () => {
     start(message?: string): void;
     stop(message?: string): void;
@@ -285,11 +77,7 @@ export type PromptGroupAwaitedReturn<T> = {
     [P in keyof T]: Exclude<Awaited<T[P]>, symbol>;
 };
 export type PromptGroupOptions<T> = {
-    /**
-     * Control how the group can be canceled
-     * if one of the prompts is canceled.
-     */
-    onCancel?: (opts: {
+        onCancel?: (opts: {
         results: Prettify<Partial<PromptGroupAwaitedReturn<T>>>;
     }) => void;
 };
@@ -301,10 +89,4 @@ export type PromptGroup<T> = {
         results: Prettify<Partial<PromptGroupAwaitedReturn<Omit<T, P>>>>;
     }) => void | Promise<T[P] | void>;
 };
-/**
- * Groups multiple prompts together so that they can be displayed and resolved in sequence.
- * @param {PromptGroup<T>} prompts - The prompts to display in the group. See {@link PromptGroup}.
- * @param {PromptGroupOptions<T>} [opts] - Optional settings for the prompt group. See {@link PromptGroupOptions}.
- * @returns {Promise<Prettify<PromptGroupAwaitedReturn<T>>>} A promise that resolves to an object containing the results of each prompt in the group.
- */
 export declare const group: <T>(prompts: PromptGroup<T>, opts?: PromptGroupOptions<T>) => Promise<Prettify<PromptGroupAwaitedReturn<T>>>;

package/dist-npm/components/prompts/promptTwo.js

@@ -568,43 +568,22 @@ export const log = {
     process.stdout.write(`${parts.join("\n")}
 `);
   },
-  /**
-   * Logs an information message, prefixed with a blue info icon.
-   * @param {string} message - The message to log.
-   */
-  info: (message) => {
+    info: (message) => {
     log.message(message, { symbol: color.blue(S_INFO) });
   },
-  /**
-   * Logs a success message, preceded by a green check symbol.
-   * @param {string} message - The message to log.
-   */
-  success: (message) => {
+    success: (message) => {
     log.message(message, { symbol: color.green(S_SUCCESS) });
   },
-  /**
-   * Logs a step message, typically used to indicate a step in a process, preceded by a green submit symbol.
-   * @param {string} message - The message to log.
-   */
-  step: (message) => {
+    step: (message) => {
     log.message(message, { symbol: color.green(S_STEP_SUBMIT) });
   },
-  /**
-   * Logs a warning message, preceded by a yellow warning icon.
-   * @param {string} message - The message to log.
-   */
-  warn: (message) => {
+    warn: (message) => {
     log.message(message, { symbol: color.yellow(S_WARN) });
   },
-  /** alias for `log.warn()`. See {@link log.warn}. */
-  warning: (message) => {
+    warning: (message) => {
     log.warn(message);
   },
-  /**
-   * Logs an error message, preceded by a red error icon.
-   * @param {string} message - The message to log.
-   */
-  error: (message) => {
+    error: (message) => {
     log.message(message, { symbol: color.red(S_ERROR) });
   }
 };

package/dist-npm/components/prompts/relinka.d.ts

@@ -1,12 +1,6 @@
 import type { PromptOptions } from "../../components/mono/monoTwo.js";
 import type { RelinkaReporter, InputLogObject, LogObject, RelinkaOptions } from "../../types/general.js";
 import type { LogType } from "../../utils/constants.js";
-/**
- * Relinka class for logging management with support for pause/resume, mocking and customizable reporting.
- * Provides flexible logging capabilities including level-based logging, custom reporters and integration options.
- *
- * @class Relinka
- */
 export declare class Relinka {
     options: RelinkaOptions;
     _lastLog: {
@@ -17,112 +11,27 @@ export declare class Relinka {
         timeout?: ReturnType<typeof setTimeout>;
     };
     _mockFn?: RelinkaOptions["mockFn"];
-    /**
-     * Creates an instance of Relinka with specified options or defaults.
-     *
-     * @param {Partial<RelinkaOptions>} [options={}] - Configuration options for the Relinka instance.
-     */
-    constructor(options?: Partial<RelinkaOptions>);
-    /**
-     * Gets the current log level of the Relinka instance.
-     *
-     * @returns {number} The current log level.
-     */
-    get level(): any;
-    /**
-     * Sets the minimum log level that will be output by the instance.
-     *
-     * @param {number} level - The new log level to set.
-     */
-    set level(level: any);
-    /**
-     * Displays a prompt to the user and returns the response.
-     * Throw an error if `prompt` is not supported by the current configuration.
-     *
-     * @template T
-     * @param {string} message - The message to display in the prompt.
-     * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
-     * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
-     */
-    prompt<T extends PromptOptions>(message: string, opts?: T): any;
-    /**
-     * Creates a new instance of Relinka, inheriting options from the current instance, with possible overrides.
-     *
-     * @param {Partial<RelinkaOptions>} options - Optional overrides for the new instance. See {@link RelinkaOptions}.
-     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
-     */
-    create(options: Partial<RelinkaOptions>): RelinkaInstance;
-    /**
-     * Creates a new Relinka instance with the specified default log object properties.
-     *
-     * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
-     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
-     */
-    withDefaults(defaults: InputLogObject): RelinkaInstance;
-    /**
-     * Creates a new Relinka instance with a specified tag, which will be included in every log.
-     *
-     * @param {string} tag - The tag to include in each log of the new instance.
-     * @returns {RelinkaInstance} A new Relinka instance. See {@link RelinkaInstance}.
-     */
-    withTag(tag: string): RelinkaInstance;
-    /**
-     * Adds a custom reporter to the Relinka instance.
-     * Reporters will be called for each log message, depending on their implementation and log level.
-     *
-     * @param {RelinkaReporter} reporter - The reporter to add. See {@link RelinkaReporter}.
-     * @returns {Relinka} The current Relinka instance.
-     */
-    addReporter(reporter: RelinkaReporter): this;
-    /**
-     * Removes a custom reporter from the Relinka instance.
-     * If no reporter is specified, all reporters will be removed.
-     *
-     * @param {RelinkaReporter} reporter - The reporter to remove. See {@link RelinkaReporter}.
-     * @returns {Relinka} The current Relinka instance.
-     */
-    removeReporter(reporter: RelinkaReporter): any;
-    /**
-     * Replaces all reporters of the Relinka instance with the specified array of reporters.
-     *
-     * @param {RelinkaReporter[]} reporters - The new reporters to set. See {@link RelinkaReporter}.
-     * @returns {Relinka} The current Relinka instance.
-     */
-    setReporters(reporters: RelinkaReporter[]): this;
+        constructor(options?: Partial<RelinkaOptions>);
+        get level(): any;
+        set level(level: any);
+        prompt<T extends PromptOptions>(message: string, opts?: T): any;
+        create(options: Partial<RelinkaOptions>): RelinkaInstance;
+        withDefaults(defaults: InputLogObject): RelinkaInstance;
+        withTag(tag: string): RelinkaInstance;
+        addReporter(reporter: RelinkaReporter): this;
+        removeReporter(reporter: RelinkaReporter): any;
+        setReporters(reporters: RelinkaReporter[]): this;
     wrapAll(): void;
     restoreAll(): void;
-    /**
-     * Overrides console methods with Relinka logging methods for consistent logging.
-     */
-    wrapConsole(): void;
-    /**
-     * Restores the original console methods, removing Relinka overrides.
-     */
-    restoreConsole(): void;
-    /**
-     * Overrides standard output and error streams to redirect them through Relinka.
-     */
-    wrapStd(): void;
+        wrapConsole(): void;
+        restoreConsole(): void;
+        wrapStd(): void;
     _wrapStream(stream: NodeJS.WriteStream | undefined, type: LogType): void;
-    /**
-     * Restores the original standard output and error streams, removing the Relinka redirection.
-     */
-    restoreStd(): void;
+        restoreStd(): void;
     _restoreStream(stream?: NodeJS.WriteStream): void;
-    /**
-     * Pauses logging, queues incoming logs until resumed.
-     */
-    pauseLogs(): void;
-    /**
-     * Resumes logging, processing any queued logs.
-     */
-    resumeLogs(): void;
-    /**
-     * Replaces logging methods with mocks if a mock function is provided.
-     *
-     * @param {RelinkaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link RelinkaOptions["mockFn"]}.
-     */
-    mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
+        pauseLogs(): void;
+        resumeLogs(): void;
+        mockTypes(mockFn?: RelinkaOptions["mockFn"]): void;
     _wrapLogFn(defaults: InputLogObject, isRaw?: boolean): (...args: any[]) => false | undefined;
     _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean): false | undefined;
     _log(logObj: LogObject): void;
@@ -132,10 +41,4 @@ export type LogFn = {
     raw: (...args: any[]) => void;
 };
 export type RelinkaInstance = Relinka & Record<LogType, LogFn>;
-/**
- * Utility for creating a new Relinka instance with optional configuration.
- *
- * @param {Partial<RelinkaOptions>} [options={}] - Optional configuration options for the new Relinka instance. See {@link RelinkaOptions}.
- * @returns {RelinkaInstance} A new instance of Relinka. See {@link RelinkaInstance}.
- */
 export declare function createRelinka(options?: Partial<RelinkaOptions>): RelinkaInstance;