@reliverse/relinka 1.1.4 → 1.1.6

package/dist-npm/components/input/index.js

@@ -1,66 +1,92 @@
 import {
-  createPrompt,
-  useState,
-  useKeypress,
-  usePrefix,
-  isEnterKey,
-  isBackspaceKey,
-  makeTheme
-} from "../../components/core/index.js";
+    createPrompt,
+    useState,
+    useKeypress,
+    usePrefix,
+    isEnterKey,
+    isBackspaceKey,
+    makeTheme,
+} from '../../components/core/index.js';
+
+const isFn = (a) => typeof a === 'function';
+
 export default createPrompt((config, done) => {
-  const { required, validate = () => true } = config;
-  const theme = makeTheme(config.theme);
-  const [status, setStatus] = useState("idle");
-  const [defaultValue = "", setDefaultValue] = useState(config.default);
-  const [errorMsg, setError] = useState();
-  const [value, setValue] = useState("");
-  const prefix = usePrefix({ status, theme });
-  useKeypress(async (key, rl) => {
-    if (status !== "idle") {
-      return;
+    const {required, validate = () => true} = config;
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [defaultValue = '', setDefaultValue] = useState(config.default);
+    const [errorMsg, setError] = useState();
+    const [value, setValue] = useState('');
+    const prefix = usePrefix({
+        status,
+        theme,
+    });
+    
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle') {
+            return;
+        }
+        
+        if (isEnterKey(key)) {
+            const answer = value || defaultValue;
+            setStatus('loading');
+            const isValid = required && !answer ? 'You must provide a value' : await validate(answer);
+            
+            if (isValid) {
+                setValue(answer);
+                setStatus('done');
+                done(answer);
+            } else {
+                rl.write(value);
+                setError(isValid || 'You must provide a valid value');
+                setStatus('idle');
+            }
+        } else if (isBackspaceKey(key) && !value) {
+            setDefaultValue(void 0);
+        } else if (key.name === 'tab' && !value) {
+            setDefaultValue(void 0);
+            rl.clearLine(0);
+            rl.write(defaultValue);
+            setValue(defaultValue);
+        } else {
+            setValue(rl.line);
+            setError(void 0);
+        }
+
+    });
+    const message = theme.style.message(config.message, status);
+    let formattedValue = value;
+    
+    if (isFn(config.transformer)) {
+        formattedValue = config.transformer(value, {
+            isFinal: status === 'done',
+        });
+    } else if (status === 'done') {
+        formattedValue = theme.style.answer(value);
     }
-    if (isEnterKey(key)) {
-      const answer = value || defaultValue;
-      setStatus("loading");
-      const isValid = required && !answer ? "You must provide a value" : await validate(answer);
-      if (isValid === true) {
-        setValue(answer);
-        setStatus("done");
-        done(answer);
-      } else {
-        rl.write(value);
-        setError(isValid || "You must provide a valid value");
-        setStatus("idle");
-      }
-    } else if (isBackspaceKey(key) && !value) {
-      setDefaultValue(void 0);
-    } else if (key.name === "tab" && !value) {
-      setDefaultValue(void 0);
-      rl.clearLine(0);
-      rl.write(defaultValue);
-      setValue(defaultValue);
-    } else {
-      setValue(rl.line);
-      setError(void 0);
+
+    
+    let defaultStr;
+    
+    if (defaultValue && status !== 'done' && !value) {
+        defaultStr = theme.style.defaultAnswer(defaultValue);
     }
-  });
-  const message = theme.style.message(config.message, status);
-  let formattedValue = value;
-  if (typeof config.transformer === "function") {
-    formattedValue = config.transformer(value, { isFinal: status === "done" });
-  } else if (status === "done") {
-    formattedValue = theme.style.answer(value);
-  }
-  let defaultStr;
-  if (defaultValue && status !== "done" && !value) {
-    defaultStr = theme.style.defaultAnswer(defaultValue);
-  }
-  let error = "";
-  if (errorMsg) {
-    error = theme.style.error(errorMsg);
-  }
-  return [
-    [prefix, message, defaultStr, formattedValue].filter((v) => v !== void 0).join(" "),
-    error
-  ];
+    
+    let error = '';
+    
+    if (errorMsg) {
+        error = theme.style.error(errorMsg);
+    }
+    
+    return [
+        [
+            prefix,
+            message,
+            defaultStr,
+            formattedValue,
+        ]
+            .filter((v) => v !== void 0)
+            .join(' '),
+        error,
+    ];
 });

package/dist-npm/components/input/text-main.js

@@ -1,92 +1,130 @@
-import { Value } from "@sinclair/typebox/value";
-import { stdin as input, stdout as output } from "node:process";
-import readline from "node:readline/promises";
-import { fmt, msg } from "../../utils/messages.js";
+import {Value} from '@sinclair/typebox/value';
 import {
-  countLines,
-  deleteLastLine,
-  deleteLastLines
-} from "../../utils/terminal.js";
+    stdin as input,
+    stdout as output,
+} from 'node:process';
+import readline from 'node:readline/promises';
+import {fmt, msg} from '../../utils/messages.js';
+import {
+    countLines,
+    deleteLastLine,
+    deleteLastLines,
+} from '../../utils/terminal.js';
+
+const isString = (a) => typeof a === 'string';
+
 export async function textPrompt(options) {
-  const {
-    title,
-    hint,
-    validate,
-    defaultValue = "",
-    schema,
-    titleColor = "cyanBright",
-    answerColor = "none",
-    titleTypography = "bold",
-    titleVariant,
-    content,
-    contentColor,
-    contentTypography,
-    contentVariant,
-    borderColor = "viceGradient",
-    variantOptions
-  } = options;
-  const rl = readline.createInterface({ input, output });
-  let linesToDelete = 0;
-  let errorMessage = "";
-  while (true) {
-    if (linesToDelete > 0) {
-      deleteLastLines(linesToDelete);
-    }
-    const question = fmt({
-      type: errorMessage !== "" ? "M_ERROR" : "M_GENERAL",
-      title,
-      titleColor,
-      titleTypography,
-      titleVariant,
-      content,
-      contentColor,
-      contentTypography,
-      contentVariant,
-      borderColor,
-      hint,
-      variantOptions,
-      errorMessage
+    const {
+        title,
+        hint,
+        validate,
+        defaultValue = '',
+        schema,
+        titleColor = 'cyanBright',
+        titleTypography = 'bold',
+        titleVariant,
+        content,
+        contentColor,
+        contentTypography,
+        contentVariant,
+        borderColor = 'viceGradient',
+        variantOptions,
+        placeholder,
+    } = options;
+    
+    const rl = readline.createInterface({
+        input,
+        output,
     });
-    const questionLines = countLines(question);
-    const prompt = await rl.question(question);
-    linesToDelete = questionLines + 1;
-    const answer = prompt.trim() || defaultValue;
-    if (prompt.trim() === "" && defaultValue !== "") {
-      deleteLastLine();
-      const defaultMsg = fmt({
-        type: "M_MIDDLE",
-        title: `  ${defaultValue}`,
-        borderColor
-      });
-      console.log(defaultMsg);
-      linesToDelete += countLines(defaultMsg);
-    }
-    let isValid = true;
-    errorMessage = "";
-    if (schema) {
-      isValid = Value.Check(schema, answer);
-      if (!isValid) {
-        const errors = [...Value.Errors(schema, answer)];
-        if (errors.length > 0) {
-          errorMessage = errors[0]?.message ?? "Invalid input.";
-        } else {
-          errorMessage = "Invalid input.";
+    let linesToDelete = 0;
+    let errorMessage = '';
+    let currentInput = '';
+    let showPlaceholder = true;
+    
+    while (true) {
+        if (linesToDelete > 0) {
+            deleteLastLines(linesToDelete);
         }
-      }
-    }
-    if (validate && isValid) {
-      const validation = await validate(answer);
-      if (validation !== true) {
-        isValid = false;
-        errorMessage = typeof validation === "string" ? validation : "Invalid input.";
-      }
-    }
-    if (isValid) {
-      msg({ type: "M_NEWLINE" });
-      rl.close();
-      return answer;
-    } else {
-      linesToDelete += 0;
+        
+        const question = fmt({
+            type: errorMessage !== '' ? 'M_ERROR' : 'M_GENERAL',
+            title,
+            titleColor,
+            titleTypography,
+            titleVariant,
+            content,
+            contentColor,
+            contentTypography,
+            contentVariant,
+            borderColor,
+            hint,
+            placeholder: showPlaceholder ? placeholder : void 0,
+            variantOptions,
+            errorMessage,
+        });
+        
+        const questionLines = countLines(question);
+        const prompt = await rl.question(question);
+        
+        currentInput = prompt.trim();
+        if (showPlaceholder && currentInput !== '') {
+            showPlaceholder = false;
+            deleteLastLine();
+            deleteLastLine();
+            msg({
+                type: 'M_MIDDLE',
+                title: `  ${currentInput}`,
+            });
+        }
+        
+        linesToDelete = questionLines + 1;
+        const answer = currentInput || defaultValue;
+        
+        if (currentInput === '' && defaultValue !== '') {
+            deleteLastLine();
+            deleteLastLine();
+            const defaultMsg = fmt({
+                type: 'M_MIDDLE',
+                title: `  ${defaultValue}`,
+                borderColor,
+            });
+            
+            linesToDelete += countLines(defaultMsg);
+        }
+        
+        let isValid = true;
+        
+        errorMessage = '';
+        if (schema) {
+            isValid = Value.Check(schema, answer);
+            if (!isValid) {
+                const errors = Value.Errors(schema, answer);
+                
+                if (errors.length > 0) {
+                    errorMessage = errors[0]?.message ?? 'Invalid input.';
+                } else {
+                    errorMessage = 'Invalid input.';
+                }
+            }
+        }
+        
+        if (validate && isValid) {
+            const validation = await validate(answer);
+            
+            if (!validation) {
+                isValid = false;
+                errorMessage = isString(validation) ? validation : 'Invalid input.';
+            }
+        }
+        
+        if (isValid) {
+            msg({
+                type: 'M_NEWLINE',
+            });
+            rl.close();
+            return answer;
+        }
+        
+        linesToDelete += 0;
     }
-  }
 }

package/dist-npm/components/input/text.js

@@ -1,26 +1,30 @@
-import color from "picocolors";
-import Prompt from "../prompts/prompt.js";
+import color from 'picocolors';
+import Prompt from '../prompts/prompt.js';
+
 export default class TextPrompt extends Prompt {
-  valueWithCursor = "";
-  get cursor() {
-    return this._cursor;
-  }
-  constructor(opts) {
-    super(opts);
-    this.on("finalize", () => {
-      if (!this.value) {
-        this.value = opts.defaultValue;
-      }
-      this.valueWithCursor = this.value;
-    });
-    this.on("value", () => {
-      if (this.cursor >= this.value.length) {
-        this.valueWithCursor = `${this.value}${color.inverse(color.hidden("_"))}`;
-      } else {
-        const s1 = this.value.slice(0, this.cursor);
-        const s2 = this.value.slice(this.cursor);
-        this.valueWithCursor = `${s1}${color.inverse(s2[0])}${s2.slice(1)}`;
-      }
-    });
-  }
+    valueWithCursor = '';
+    get cursor() {
+        return this._cursor;
+    }
+    
+    constructor(opts) {
+        super(opts);
+        this.on('finalize', () => {
+            if (!this.value) {
+                this.value = opts.defaultValue;
+            }
+            
+            this.valueWithCursor = this.value;
+        });
+        this.on('value', () => {
+            if (this.cursor >= this.value.length) {
+                this.valueWithCursor = `${this.value}${color.inverse(color.hidden('_'))}`;
+            } else {
+                const s1 = this.value.slice(0, this.cursor);
+                const s2 = this.value.slice(this.cursor);
+                
+                this.valueWithCursor = `${s1}${color.inverse(s2[0])}${s2.slice(1)}`;
+            }
+        });
+    }
 }

package/dist-npm/components/instance/basic.js

@@ -1,21 +1,29 @@
-import { BasicReporter } from "../../components/instance/reporter/basic.js";
-import { createRelinka as _createRelinka } from "../../components/prompts/relinka.js";
-import { LogLevels } from "../../utils/constants.js";
-export * from "../../components/instance/shared.js";
+import {BasicReporter} from '../../components/instance/reporter/basic.js';
+import {createRelinka as _createRelinka} from '../../components/prompts/relinka.js';
+import process from 'node:process';
+import {LogLevels} from '../../utils/constants.js';
+
+export * from '../../components/instance/shared.js';
 export function createRelinka(options = {}) {
-  let level = LogLevels.info;
-  if (process.env.RELINKA_LEVEL) {
-    level = Number.parseInt(process.env.RELINKA_LEVEL) ?? level;
-  }
-  const relinka2 = _createRelinka({
-    level,
-    defaults: { level },
-    stdout: process.stdout,
-    stderr: process.stderr,
-    reporters: options.reporters || [new BasicReporter()],
-    ...options
-  });
-  return relinka2;
+    let level = LogLevels.info;
+    
+    if (process.env.RELINKA_LEVEL) {
+        level = Number.parseInt(process.env.RELINKA_LEVEL) ?? level;
+    }
+    
+    const relinka2 = _createRelinka({
+        level,
+        defaults: {
+            level,
+        },
+        stdout: process.stdout,
+        stderr: process.stderr,
+        reporters: options.reporters || [new BasicReporter()],
+        ...options,
+    });
+    
+    return relinka2;
 }
+
 export const relinka = createRelinka();
 export default relinka;

package/dist-npm/components/instance/browser.js

@@ -1,18 +1,22 @@
-import { BrowserReporter } from "../../components/instance/reporter/browser.js";
-import { createRelinka as _createRelinka } from "../../components/prompts/relinka.js";
-export * from "../../components/instance/shared.js";
+import {BrowserReporter} from '../../components/instance/reporter/browser.js';
+import {createRelinka as _createRelinka} from '../../components/prompts/relinka.js';
+
+export * from '../../components/instance/shared.js';
 export function createRelinka(options = {}) {
-  const relinka2 = _createRelinka({
-    reporters: options.reporters || [new BrowserReporter({})],
-    prompt(message, options2 = {}) {
-      if (options2.type === "confirm") {
-        return Promise.resolve(confirm(message));
-      }
-      return Promise.resolve(prompt(message));
-    },
-    ...options
-  });
-  return relinka2;
+    const relinka2 = _createRelinka({
+        reporters: options.reporters || [new BrowserReporter({})],
+        prompt(message, options2 = {}) {
+            if (options2.type === 'confirm') {
+                return Promise.resolve(confirm(message));
+            }
+            
+            return Promise.resolve(prompt(message));
+        },
+        ...options,
+    });
+    
+    return relinka2;
 }
+
 export const relinka = createRelinka();
 export default relinka;

package/dist-npm/components/instance/reporter/basic.js

@@ -1,49 +1,68 @@
-import { formatWithOptions } from "node:util";
-import { parseStack } from "../../../utils/error.js";
-import { writeStream } from "../../../utils/stream.js";
-const bracket = (x) => x ? `[${x}]` : "";
+import {formatWithOptions} from 'node:util';
+import process from 'node:process';
+import {parseStack} from '../../../utils/error.js';
+import {writeStream} from '../../../utils/stream.js';
+
+const isString = (a) => typeof a === 'string';
+const bracket = (x) => x ? `[${x}]` : '';
+
 export class BasicReporter {
-  formatStack(stack, opts) {
-    return "  " + parseStack(stack).join("\n  ");
-  }
-  formatArgs(args, opts) {
-    const _args = args.map((arg) => {
-      if (arg && typeof arg.stack === "string") {
-        return arg.message + "\n" + this.formatStack(arg.stack, opts);
-      }
-      return arg;
-    });
-    return formatWithOptions(opts, ..._args);
-  }
-  formatDate(date, opts) {
-    return opts.date ? date.toLocaleTimeString() : "";
-  }
-  filterAndJoin(arr) {
-    return arr.filter(Boolean).join(" ");
-  }
-  formatLogObj(logObj, opts) {
-    const message = this.formatArgs(logObj.args, opts);
-    if (logObj.type === "box") {
-      return "\n" + [
-        bracket(logObj.tag),
-        logObj.title && logObj.title,
-        ...message.split("\n")
-      ].filter(Boolean).map((l) => " > " + l).join("\n") + "\n";
+    formatStack(stack) {
+        return '  ' + parseStack(stack).join('\n  ');
+    }
+    
+    formatArgs(args, opts) {
+        const _args = args.map((arg) => {
+            if (arg && isString(arg.stack)) {
+                return arg.message + '\n' + this.formatStack(arg.stack, opts);
+            }
+            
+            return arg;
+        });
+        
+        return formatWithOptions(opts, ..._args);
+    }
+    
+    formatDate(date, opts) {
+        return opts.date ? date.toLocaleTimeString() : '';
+    }
+    
+    filterAndJoin(arr) {
+        return arr
+            .filter(Boolean)
+            .join(' ');
+    }
+    
+    formatLogObj(logObj, opts) {
+        const message = this.formatArgs(logObj.args, opts);
+        
+        if (logObj.type === 'box') {
+            return `
+${[
+                bracket(logObj.tag),
+                logObj.title,
+                ...message.split('\n'),
+            ]
+                .filter(Boolean)
+                .map((l) => ` > ${l}`)
+                .join('\n')}
+`;
+        }
+        
+        return this.filterAndJoin([
+            bracket(logObj.type),
+            bracket(logObj.tag),
+            message,
+        ]);
+    }
+    
+    log(logObj, ctx) {
+        const line = this.formatLogObj(logObj, {
+            columns: ctx.options.stdout.columns || 0,
+            ...ctx.options.formatOptions,
+        });
+        
+        return writeStream(`${line}
+`, logObj.level < 2 ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout);
     }
-    return this.filterAndJoin([
-      bracket(logObj.type),
-      bracket(logObj.tag),
-      message
-    ]);
-  }
-  log(logObj, ctx) {
-    const line = this.formatLogObj(logObj, {
-      columns: ctx.options.stdout.columns || 0,
-      ...ctx.options.formatOptions
-    });
-    return writeStream(
-      line + "\n",
-      logObj.level < 2 ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout
-    );
-  }
 }