@reliverse/rempts 1.7.52 → 1.7.53

package/bin/libs/launcher/launcher-types.d.ts

@@ -0,0 +1,176 @@
+export type EmptyArgs = Record<string, never>;
+export interface BaseArgProps {
+    description?: string;
+    required?: boolean;
+    allowed?: readonly string[];
+}
+export interface BaseArgDefinition {
+    type: string;
+    description?: string;
+    required?: boolean;
+    default?: any;
+    allowed?: readonly any[];
+    dependencies?: string[];
+}
+export type PositionalArgDefinition = BaseArgDefinition & {
+    type: "positional";
+    default?: string;
+    allowed?: readonly string[];
+};
+export type BooleanArgDefinition = BaseArgDefinition & {
+    type: "boolean";
+    default?: boolean;
+    allowed?: readonly boolean[];
+    alias?: string;
+};
+export type StringArgDefinition = BaseArgDefinition & {
+    type: "string";
+    default?: string;
+    allowed?: readonly string[];
+    alias?: string;
+};
+export type NumberArgDefinition = BaseArgDefinition & {
+    type: "number";
+    default?: number;
+    allowed?: readonly number[];
+    alias?: string;
+};
+export type ArrayArgDefinition = BaseArgDefinition & {
+    type: "array";
+    default?: string | readonly string[];
+    allowed?: readonly string[];
+    alias?: string;
+};
+export type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
+export type ArgDefinitions = Record<string, ArgDefinition>;
+export interface CommandMeta {
+    name: string;
+    version?: string;
+    description?: string;
+    hidden?: boolean;
+    aliases?: string[];
+}
+/**
+ * A subcommand can be either:
+ * 1) A string path to a module with a default export of type Command.
+ * 2) A lazy import function returning a Promise that resolves to
+ *    { default: Command<any> } or directly to a Command instance.
+ */
+export type CommandSpec = string | (() => Promise<{
+    default: Command<any>;
+} | Command<any>>);
+export type CommandsMap = Record<string, CommandSpec>;
+export interface CommandContext<ARGS> {
+    args: ARGS;
+    raw: string[];
+}
+export type CommandRun<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+export type CommandHook<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+export interface DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> {
+    meta?: CommandMeta;
+    args?: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    /**
+     * Object subcommands for this command.
+     */
+    commands?: CommandsMap;
+    /**
+     * @deprecated Use `commands` instead. Will be removed in a future major version.
+     */
+    subCommands?: CommandsMap;
+    /**
+     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdInit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdExit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdInit instead
+     */
+    setup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdExit instead
+     */
+    cleanup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherInit?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherExit?: () => void | Promise<void>;
+}
+export interface Command<A extends ArgDefinitions = EmptyArgs> {
+    meta?: CommandMeta;
+    args: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    /**
+     * Object subcommands for this command.
+     */
+    commands?: CommandsMap;
+    /**
+     * @deprecated Use `commands` instead. Will be removed in a future major version.
+     */
+    subCommands?: CommandsMap;
+    /**
+     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdInit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdExit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdInit instead
+     */
+    setup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdExit instead
+     */
+    cleanup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherInit?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherExit?: () => void | Promise<void>;
+}
+type ExtractAllowed<T extends ArgDefinition> = T extends {
+    type: "positional";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "positional";
+} ? string : T extends {
+    type: "boolean";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "boolean";
+} ? boolean : T extends {
+    type: "string";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "string";
+} ? string : T extends {
+    type: "number";
+    allowed: readonly (infer U)[];
+} ? U : T extends {
+    type: "number";
+} ? number : T extends {
+    type: "array";
+    allowed: readonly (infer U)[];
+} ? U[] : T extends {
+    type: "array";
+} ? string[] : never;
+export type InferArgTypes<A extends ArgDefinitions> = {
+    [K in keyof A]: ExtractAllowed<A[K]>;
+};
+export interface FileBasedOptions {
+    enable: boolean;
+    cmdsRootPath: string;
+}
+export {};

package/bin/libs/log/log-alias.d.ts

@@ -0,0 +1 @@
+export declare const log: import("@reliverse/relinka").RelinkaFunction;

package/bin/libs/log/log-alias.js

@@ -0,0 +1,2 @@
+import { relinka } from "@reliverse/relinka";
+export const log = relinka;

package/bin/libs/msg-fmt/colors.d.ts

@@ -0,0 +1,30 @@
+import type { ColorName, OutputColor, StandardColor } from "../../types";
+/**
+ * Maps complex colors (gradients, bright, background) to standard terminal colors.
+ * Used by ora spinners and other terminal utilities that only support basic colors.
+ *
+ * Handles:
+ * - Gradient colors -> solid colors (e.g., retroGradient -> cyan)
+ * - Bright colors -> base colors (e.g., redBright -> red)
+ * - Background colors -> foreground colors (e.g., bgRed -> red)
+ * - Special colors -> undefined (reset, inverse, dim, none)
+ *
+ * @param color The complex color to convert
+ * @returns A standard terminal color or undefined for special colors
+ */
+export declare function toBaseColor(color?: ColorName): StandardColor | undefined;
+/**
+ * Maps any color type to a standard solid color for consistent display.
+ * Similar to toBaseColor but always returns a color (never undefined).
+ *
+ * Handles:
+ * - Gradient colors -> solid colors (e.g., retroGradient -> cyan)
+ * - Bright colors -> base colors (e.g., redBright -> red)
+ * - Background colors -> foreground colors (e.g., bgRed -> red)
+ * - Special colors (reset, inverse, none) -> dim
+ * - Undefined -> dim
+ *
+ * @param color The color to convert
+ * @returns A standard terminal color, defaulting to "dim" for special cases
+ */
+export declare function toSolidColor(color?: ColorName): OutputColor;

package/bin/libs/msg-fmt/colors.js

@@ -0,0 +1,42 @@
+const GRADIENT_COLOR_MAP = {
+  retroGradient: "cyan",
+  viceGradient: "green",
+  gradientGradient: "blue",
+  rainbowGradient: "blue",
+  cristalGradient: "blue",
+  mindGradient: "blue",
+  passionGradient: "blue"
+};
+const SPECIAL_COLORS = ["reset", "inverse", "none"];
+function stripBrightModifier(color) {
+  return color.replace("Bright", "");
+}
+function stripBgModifier(color) {
+  return color.replace("bg", "").toLowerCase();
+}
+function stripColorModifiers(color) {
+  if (color.includes("Bright")) {
+    return stripBrightModifier(color);
+  }
+  if (color.startsWith("bg")) {
+    return stripBgModifier(color);
+  }
+  return color;
+}
+export function toBaseColor(color) {
+  if (!color || color === "dim" || SPECIAL_COLORS.includes(color)) {
+    return;
+  }
+  if (color in GRADIENT_COLOR_MAP) {
+    return GRADIENT_COLOR_MAP[color];
+  }
+  if (color.includes("Bright") || color.startsWith("bg")) {
+    const baseColor = stripColorModifiers(color);
+    return baseColor;
+  }
+  return color;
+}
+export function toSolidColor(color) {
+  const baseColor = toBaseColor(color);
+  return baseColor ?? "dim";
+}

package/bin/libs/msg-fmt/logger.d.ts

@@ -0,0 +1,17 @@
+import type { AllKinds, StreamOptions } from "../../types";
+/**
+ * Logs messages with configurable styling and formatting.
+ * Doesn't support streaming functionality.
+ */
+export declare function relinkaByRemptsDeprecated(kind: AllKinds, title: string, content?: string, hint?: string): void;
+/**
+ * Asynchronous version of relinka that supports streaming functionality.
+ * Use this when you want animated text output with optional spinner.
+ *
+ * Streaming is controlled by the streamOpts parameter:
+ * - Use { useSpinner: true } for spinner animation
+ * - Use { delay: number } for character-by-character streaming
+ * - Content and hint are optional regardless of streaming
+ */
+export declare const relinkaAsyncByRemptsDeprecated: (kind: AllKinds, title: string, content?: string, hint?: string, streamOpts?: StreamOptions) => Promise<void>;
+export declare const throwError: (error: unknown) => never;

package/bin/libs/msg-fmt/logger.js

@@ -0,0 +1,103 @@
+import { streamText, streamTextWithSpinner } from "../utils/stream-text.js";
+import { toSolidColor } from "./colors.js";
+import { msg } from "./messages.js";
+const verboseLogging = false;
+const MESSAGE_CONFIGS = {
+  log: {
+    type: "M_INFO",
+    titleColor: "retroGradient",
+    titleTypography: "bold"
+  },
+  info: {
+    type: "M_INFO",
+    titleColor: "retroGradient",
+    titleTypography: "bold"
+  },
+  success: {
+    type: "M_INFO",
+    titleColor: "viceGradient",
+    titleTypography: "bold"
+  },
+  warn: {
+    type: "M_ERROR",
+    titleColor: "yellowBright",
+    titleTypography: "bold"
+  },
+  error: {
+    type: "M_ERROR",
+    titleColor: "yellowBright",
+    titleTypography: "bold"
+  }
+};
+export function relinkaByRemptsDeprecated(kind, title, content, hint) {
+  const isVerbose = kind.endsWith("-verbose");
+  const baseKind = isVerbose ? kind.replace("-verbose", "") : kind;
+  if (isVerbose && !verboseLogging) {
+    return;
+  }
+  const config = MESSAGE_CONFIGS[baseKind];
+  msg({
+    ...config,
+    title: isVerbose ? `[debug] ${title}` : title,
+    content: content ?? "",
+    contentColor: "dim",
+    contentTypography: "italic",
+    hint: hint ?? ""
+  });
+}
+export const relinkaAsyncByRemptsDeprecated = async (kind, title, content, hint, streamOpts) => {
+  const isVerbose = kind.endsWith("-verbose");
+  const baseKind = isVerbose ? kind.replace("-verbose", "") : kind;
+  if (isVerbose && !verboseLogging) {
+    return;
+  }
+  const config = MESSAGE_CONFIGS[baseKind];
+  if (!streamOpts) {
+    msg({
+      ...config,
+      title: isVerbose ? `[debug] ${title}` : title,
+      content: content ?? "",
+      contentColor: "dim",
+      contentTypography: "italic",
+      hint: hint ?? ""
+    });
+    return;
+  }
+  const titleText = isVerbose ? `[debug] ${title}` : title;
+  if (streamOpts.useSpinner) {
+    await streamTextWithSpinner({
+      text: titleText,
+      color: toSolidColor(config.titleColor),
+      delay: streamOpts.delay,
+      spinnerFrames: streamOpts.spinnerFrames,
+      spinnerDelay: streamOpts.spinnerDelay
+    });
+  } else {
+    await streamText({
+      text: titleText,
+      color: toSolidColor(config.titleColor),
+      delay: streamOpts.delay
+    });
+  }
+  if (content) {
+    await streamText({
+      text: content,
+      color: toSolidColor(config.contentColor) ?? "dim",
+      delay: streamOpts.delay
+    });
+  }
+  if (hint) {
+    await streamText({
+      text: hint,
+      color: "dim",
+      delay: streamOpts.delay
+    });
+  }
+};
+export const throwError = (error) => {
+  msg({
+    type: "M_ERROR",
+    title: error instanceof Error ? `\u{1F914} Failed to set up the project: ${error.message}` : "\u{1F914} An unknown error occurred."
+  });
+  process.exit(1);
+};

package/bin/libs/msg-fmt/mapping.d.ts

@@ -0,0 +1,3 @@
+import type { ColorName, TypographyName } from "../../types";
+export declare const colorMap: Record<ColorName, (text: string) => string>;
+export declare const typographyMap: Record<TypographyName, (text: string) => string>;

package/bin/libs/msg-fmt/mapping.js

@@ -0,0 +1,41 @@
+import { re } from "@reliverse/relico";
+import gradient, { cristal, mind, passion, rainbow, retro, vice } from "gradient-string";
+export const colorMap = {
+  // @reliverse/relico
+  none: (text) => text,
+  reset: re.reset,
+  bgCyan: re.bgCyan,
+  bgCyanBright: re.bgCyanBright,
+  black: re.black,
+  blue: re.blue,
+  blueBright: re.blueBright,
+  cyan: re.cyan,
+  cyanBright: re.cyanBright,
+  dim: re.dim,
+  gray: re.gray,
+  green: re.green,
+  greenBright: re.greenBright,
+  inverse: (text) => re.bold(re.inverse(text)),
+  magenta: re.magenta,
+  magentaBright: re.magentaBright,
+  red: re.red,
+  redBright: re.redBright,
+  white: re.white,
+  yellow: re.yellow,
+  yellowBright: re.yellowBright,
+  // gradient-string
+  cristalGradient: cristal,
+  gradientGradient: gradient(["red", "yellow", "green", "cyan", "blue", "magenta"]),
+  mindGradient: mind,
+  passionGradient: passion,
+  rainbowGradient: rainbow,
+  retroGradient: retro,
+  viceGradient: vice
+};
+export const typographyMap = {
+  none: (text) => text,
+  bold: re.bold,
+  italic: re.italic,
+  strikethrough: re.strikethrough,
+  underline: re.underline
+};

package/bin/libs/msg-fmt/messages.d.ts

@@ -0,0 +1,35 @@
+import type { ColorName, FmtMsgOptions, Symbols } from "../../types";
+export declare const symbols: Symbols;
+/**
+ * Returns a colored vertical bar symbol. Prevents gradient colors for bars.
+ */
+export declare const bar: ({ borderColor }?: {
+    borderColor?: ColorName;
+}) => string;
+/**
+ * Main formatter function: builds the final text output based on FmtMsgOptions.
+ */
+export declare function fmt(opts: FmtMsgOptions): {
+    text: string;
+    lineCount: number;
+};
+/**
+ * Logs a formatted message to the console and records how many lines it occupies.
+ */
+export declare function msg(opts: FmtMsgOptions): void;
+/**
+ * Undo the last printed message by deleting its lines from the terminal.
+ * @param count How many messages to undo. Defaults to 1.
+ */
+export declare function msgUndo(count?: number): void;
+/**
+ * Undo all printed messages so far.
+ */
+export declare function msgUndoAll(): void;
+/**
+ * Prints:  "│  <text>"  (two spaces after the bar).
+ * If text is empty, it just prints "│".
+ * If indent is 1, it prints "│ <text>" (one space).
+ * If indent is 2, it prints "│  <text>" (two spaces), etc.
+ */
+export declare function printLineBar(text: string, indent?: number): void;