@reliverse/relinka 1.2.7 → 1.2.9

package/dist-npm/components/messages/mapping.js

@@ -1,29 +1,29 @@
+import { re } from "@reliverse/relico";
 import gradient, { cristal, mind, passion, retro, vice } from "gradient-string";
 import { rainbow } from "gradient-string";
-import pc from "picocolors";
 export const colorMap = {
-  // picocolors
+  // @reliverse/relico
   none: (text) => text,
-  reset: pc.reset,
-  bgCyan: pc.bgCyan,
-  bgCyanBright: pc.bgCyanBright,
-  black: pc.black,
-  blue: pc.blue,
-  blueBright: pc.blueBright,
-  cyan: pc.cyan,
-  cyanBright: pc.cyanBright,
-  dim: pc.dim,
-  gray: pc.gray,
-  green: pc.green,
-  greenBright: pc.greenBright,
-  inverse: (text) => pc.bold(pc.inverse(text)),
-  magenta: pc.magenta,
-  magentaBright: pc.magentaBright,
-  red: pc.red,
-  redBright: pc.redBright,
-  white: pc.white,
-  yellow: pc.yellow,
-  yellowBright: pc.yellowBright,
+  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([
@@ -42,8 +42,8 @@ export const colorMap = {
 };
 export const typographyMap = {
   none: (text) => text,
-  bold: pc.bold,
-  italic: pc.italic,
-  strikethrough: pc.strikethrough,
-  underline: pc.underline
+  bold: re.bold,
+  italic: re.italic,
+  strikethrough: re.strikethrough,
+  underline: re.underline
 };

package/dist-npm/components/messages/messages.d.ts

@@ -4,7 +4,7 @@ import { type VariantName } from "./variants.js";
 /**
  * Known symbol names that will have IntelliSense support
  */
-export type SymbolName = "pointer" | "start" | "middle" | "end" | "line" | "corner_top_right" | "step_active" | "step_error" | "info";
+export type SymbolName = "pointer" | "start" | "middle" | "end" | "line" | "corner_top_right" | "step_active" | "step_error" | "info" | "success";
 export type FmtMsgOptions = {
     type: MsgType;
     title?: string;
@@ -54,14 +54,13 @@ export declare const symbols: {
     readonly success: string;
 };
 /**
- * Returns a colored vertical bar symbol.
+ * Returns a colored vertical bar symbol. Prevents gradient colors for bars.
  */
-export declare const bar: ({ borderColor, }: {
+export declare const bar: ({ borderColor, }?: {
     borderColor?: ColorName;
 }) => string;
 /**
- * Formats a message line according to the given FmtMsgOptions.
- * Returns both the formatted text and the number of lines it would occupy.
+ * Main formatter function: builds the final text output based on FmtMsgOptions.
  */
 export declare function fmt(opts: FmtMsgOptions): {
     text: string;
@@ -83,7 +82,6 @@ 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.
+ * If indent is 1, it prints "│ <text>", etc.
  */
 export declare function printLineBar(text: string, indent?: number): void;

package/dist-npm/components/messages/messages.js

@@ -1,4 +1,4 @@
-import pc from "picocolors";
+import { re } from "@reliverse/relico";
 import wrapAnsi from "wrap-ansi";
 import { colorMap, typographyMap } from "./mapping.js";
 import { isUnicodeSupported } from "./platforms.js";
@@ -22,44 +22,35 @@ export const symbols = {
   info: u("\u2139", "i"),
   success: u("\u2705", "\u2713")
 };
-function wrapAndStyleText(input, typographyName, colorName, variantName, borderColor) {
-  const adjustedWidth = getTerminalWidth();
-  const wrappedText = wrapAnsi(input, adjustedWidth, {
-    hard: false,
-    trim: true
-  });
-  return wrappedText.split("\n").map((line) => {
-    const isOption = line.startsWith("  ") || line.startsWith("[ ]") || line.startsWith("[x]");
-    return applyStyles(
-      line,
-      colorName && !isOption ? colorName : void 0,
-      typographyName && !isOption ? typographyName : void 0,
-      variantName && variantName !== "none" ? variantName : void 0,
-      borderColor
-    );
-  }).join("\n");
+function wrapThenStyle(input, wrap, typographyName, colorName, variantName, borderColor) {
+  if (!input) return "";
+  const width = getTerminalWidth();
+  const wrappedText = wrap ? wrapAnsi(input, width, { hard: false, trim: true }) : input;
+  return wrappedText.split("\n").map(
+    (line) => applyStyles(line, colorName, typographyName, variantName, borderColor)
+  ).join("\n");
 }
 function applyStyles(text, colorName, typographyName, variantName, borderColor) {
   let styledText = text;
-  if (!isValidVariant(variantName)) {
-    if (colorName && colorMap[colorName]) {
-      styledText = colorMap[colorName](styledText);
-    }
-    if (typographyName && typographyMap[typographyName]) {
-      styledText = typographyMap[typographyName](styledText);
-    }
-  } else if (variantName) {
+  if (variantName && isValidVariant(variantName)) {
     styledText = variantMap[variantName](
       [styledText],
       void 0,
       borderColor
     ).toString();
+    return styledText;
+  }
+  if (colorName && colorMap[colorName]) {
+    styledText = colorMap[colorName](styledText);
+  }
+  if (typographyName && typographyMap[typographyName]) {
+    styledText = typographyMap[typographyName](styledText);
   }
   return styledText;
 }
 export const bar = ({
   borderColor = "dim"
-}) => {
+} = {}) => {
   if (borderColor.endsWith("Gradient")) {
     console.error(
       "Gradient colors are not supported for bars. Please use a solid color instead."
@@ -71,22 +62,87 @@ export const bar = ({
 function countLines(text) {
   return text.split("\n").length;
 }
+function getColoredSymbol(customSymbol, symbolName, symbolColor) {
+  if (customSymbol) {
+    return symbolColor && colorMap[symbolColor] ? colorMap[symbolColor](customSymbol) : customSymbol;
+  }
+  if (symbolName && symbols[symbolName]) {
+    return symbolColor && colorMap[symbolColor] ? colorMap[symbolColor](symbols[symbolName]) : symbols[symbolName];
+  }
+  return void 0;
+}
+function formatTitle(opts, borderTwoSpaces, borderError) {
+  let formattedTitle = "";
+  if (!opts.title) return formattedTitle;
+  const wrappedOrStyledTitle = wrapThenStyle(
+    opts.title,
+    opts.wrapTitle ?? true,
+    opts.titleTypography ?? "bold",
+    opts.titleColor ?? "cyan",
+    opts.titleVariant,
+    opts.borderColor
+  );
+  formattedTitle += wrappedOrStyledTitle;
+  if (opts.hint) {
+    const hintColor = opts.hintPlaceholderColor ?? "blue";
+    const wrappedHint = wrapThenStyle(
+      opts.hint,
+      opts.wrapTitle ?? true,
+      // same wrap logic as title by default
+      opts.hintTypography ?? "italic",
+      hintColor,
+      void 0,
+      opts.borderColor
+    );
+    formattedTitle += `
+${borderTwoSpaces}${wrappedHint}`;
+  }
+  if (opts.placeholder && opts.type === "M_GENERAL") {
+    const placeHolderColor = opts.hintPlaceholderColor ?? "blue";
+    formattedTitle += `
+${borderTwoSpaces}${colorMap[placeHolderColor](opts.placeholder)}`;
+  }
+  if (opts.errorMessage) {
+    const formattedError = applyStyles(
+      opts.errorMessage,
+      "red",
+      "bold",
+      void 0,
+      opts.borderColor
+    );
+    formattedTitle += `
+${borderError}  ${formattedError}`;
+  }
+  return formattedTitle;
+}
+function formatContent(opts) {
+  if (!opts.content) return "";
+  return wrapThenStyle(
+    opts.content,
+    opts.wrapContent ?? true,
+    opts.contentTypography ?? "italic",
+    opts.contentColor ?? "dim",
+    opts.contentVariant,
+    opts.borderColor
+  );
+}
 export function fmt(opts) {
   if (!opts.borderColor) {
     opts.borderColor = "dim";
   }
-  const border = applyStyles(symbols.middle, opts.borderColor);
+  const borderColored = applyStyles(symbols.middle, opts.borderColor);
   const borderError = applyStyles(symbols.middle, "red");
-  const borderWithSpace = `${border}  `;
+  const borderTwoSpaces = `${borderColored}  `;
   const prefixStartLine = opts.borderColor ? colorMap[opts.borderColor](symbols.start + symbols.line) : symbols.start + symbols.line;
   const prefixEndLine = opts.borderColor ? colorMap[opts.borderColor](symbols.end + symbols.line) : symbols.end + symbols.line;
   const lineLength = opts.horizontalLineLength === 0 ? getExactTerminalWidth() - 3 : opts.horizontalLineLength ?? getExactTerminalWidth() - 3;
   const suffixStartLine = opts.borderColor ? colorMap[opts.borderColor](`${symbols.line.repeat(lineLength)}\u22B1`) : `${symbols.line.repeat(lineLength)}\u22B1`;
   const suffixEndLine = opts.borderColor ? colorMap[opts.borderColor](`${symbols.line.repeat(lineLength)}\u22B1`) : `${symbols.line.repeat(lineLength)}\u22B1`;
-  const MSG_CONFIGS = {
+  const computedSymbol = getColoredSymbol(opts.customSymbol, opts.symbol, opts.symbolColor) ?? re.green(symbols.step_active);
+  const MESSAGE_CONFIG_MAP = {
     M_NULL: {
       symbol: "",
-      prefix: borderWithSpace,
+      prefix: borderTwoSpaces,
       suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
@@ -100,7 +156,7 @@ export function fmt(opts) {
     },
     M_INFO_NULL: {
       symbol: "",
-      prefix: borderWithSpace,
+      prefix: borderTwoSpaces,
       suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
@@ -109,47 +165,49 @@ export function fmt(opts) {
       symbol: "",
       prefix: "",
       suffix: `
-${borderWithSpace}`,
+${borderTwoSpaces}`,
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     },
     M_MIDDLE: {
       symbol: "",
-      prefix: borderWithSpace,
+      prefix: borderTwoSpaces,
       suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     },
     M_GENERAL: {
-      symbol: opts.customSymbol ? opts.symbolColor ? colorMap[opts.symbolColor](opts.customSymbol) : opts.customSymbol : opts.symbol ? opts.symbolColor ? colorMap[opts.symbolColor](symbols[opts.symbol]) : symbols[opts.symbol] : pc.green(symbols.step_active),
-      prefix: borderWithSpace,
+      symbol: computedSymbol,
+      prefix: borderTwoSpaces,
       suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     },
     M_GENERAL_NULL: {
       symbol: "",
-      prefix: borderWithSpace,
+      prefix: borderTwoSpaces,
       suffix: opts.placeholder ? colorMap[opts.hintPlaceholderColor ?? "blue"](opts.placeholder) : "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     },
     M_INFO: {
-      symbol: opts.customSymbol ? opts.symbolColor ? colorMap[opts.symbolColor](opts.customSymbol) : opts.customSymbol : opts.symbol ? opts.symbolColor ? colorMap[opts.symbolColor](symbols[opts.symbol]) : symbols[opts.symbol] : pc.green(symbols.info),
-      prefix: borderWithSpace,
+      symbol: computedSymbol || re.green(symbols.info),
+      prefix: borderTwoSpaces,
       suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? true
     },
     M_ERROR: {
-      symbol: opts.customSymbol ? opts.symbolColor ? colorMap[opts.symbolColor](opts.customSymbol) : opts.customSymbol : opts.symbol ? opts.symbolColor ? colorMap[opts.symbolColor](symbols[opts.symbol]) : symbols[opts.symbol] : pc.redBright(symbols.step_error),
-      prefix: borderWithSpace,
+      symbol: computedSymbol || re.redBright(symbols.step_error),
+      prefix: borderTwoSpaces,
+      suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     },
     M_ERROR_NULL: {
       symbol: "",
-      prefix: borderWithSpace,
+      prefix: borderTwoSpaces,
+      suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     },
@@ -162,111 +220,31 @@ ${borderWithSpace}`,
     },
     M_NEWLINE: {
       symbol: "",
-      prefix: borderWithSpace,
+      prefix: borderTwoSpaces,
+      suffix: "",
       newLineBefore: opts.addNewLineBefore ?? false,
       newLineAfter: opts.addNewLineAfter ?? false
     }
   };
-  const config = MSG_CONFIGS[opts.type];
+  const config = MESSAGE_CONFIG_MAP[opts.type];
   if (!config) {
     throw new Error(`Invalid message type: ${opts.type}`);
   }
-  const {
-    symbol = "",
-    suffix = "",
-    newLineBefore = false,
-    newLineAfter = false
-  } = config;
-  function validateColorName(colorName) {
-    if (!colorMap[colorName]) {
-      throw new Error(`Invalid color name: ${colorName}`);
-    }
-  }
-  let formattedTitle = "";
-  if (opts.title) {
-    const rawTitle = opts.title;
-    if (opts.wrapTitle ?? true) {
-      formattedTitle = wrapAndStyleText(
-        rawTitle,
-        opts.titleTypography ?? "bold",
-        opts.titleColor ?? "cyan",
-        opts.titleVariant,
-        opts.borderColor
-      );
-    } else {
-      formattedTitle = applyStyles(
-        rawTitle,
-        opts.titleColor ?? "cyan",
-        opts.titleTypography ?? "bold",
-        opts.titleVariant,
-        opts.borderColor
-      );
-    }
-    if (opts.hint) {
-      const hintPlaceholderColor = opts.hintPlaceholderColor ?? "blue";
-      if (opts.hintPlaceholderColor) {
-        validateColorName(opts.hintPlaceholderColor);
-      }
-      const formattedHint = wrapAndStyleText(
-        opts.hint,
-        opts.hintTypography ?? "italic",
-        hintPlaceholderColor,
-        void 0,
-        opts.borderColor
-      );
-      formattedTitle += `
-${borderWithSpace}${formattedHint}`;
-    }
-    if (opts.placeholder && opts.type === "M_GENERAL") {
-      formattedTitle += `
-${borderWithSpace}${colorMap[opts.hintPlaceholderColor ?? "blue"](opts.placeholder)}`;
-    }
-    if (opts.errorMessage) {
-      const formattedError = applyStyles(
-        opts.errorMessage,
-        "red",
-        "bold",
-        "",
-        opts.borderColor
-      );
-      formattedTitle += `
-${borderError}  ${formattedError}`;
-    }
-  }
-  let formattedContent = "";
-  if (opts.content) {
-    const rawContent = opts.content;
-    if (opts.wrapContent ?? true) {
-      formattedContent = wrapAndStyleText(
-        rawContent,
-        opts.contentTypography ?? "italic",
-        opts.contentColor ?? "dim",
-        opts.contentVariant,
-        opts.borderColor
-      );
-    } else {
-      formattedContent = applyStyles(
-        rawContent,
-        opts.contentColor ?? "dim",
-        opts.contentTypography ?? "italic",
-        opts.contentVariant,
-        opts.borderColor
-      );
-    }
-  }
+  const { symbol, suffix, newLineBefore, newLineAfter } = config;
+  const finalTitle = formatTitle(opts, borderTwoSpaces, borderError);
+  const finalContent = formatContent(opts);
   let text = "";
   if (opts.type === "M_BAR") {
     text = bar({ borderColor: opts.borderColor });
   } else {
-    text = [formattedTitle, formattedContent].filter(Boolean).join(`
-`);
+    text = [finalTitle, finalContent].filter(Boolean).join("\n");
   }
   const fullText = [
     newLineBefore ? `
-${borderWithSpace}` : "",
+${borderTwoSpaces}` : "",
     text,
     newLineAfter ? `
-${borderWithSpace}` : "",
+${borderTwoSpaces}` : "",
     suffix
   ].filter(Boolean).join("");
   const lines = fullText.split("\n").map((line, index) => {
@@ -275,11 +253,12 @@ ${borderWithSpace}` : "",
         return `${prefixStartLine} ${line} ${suffixStartLine}`;
       }
       if (index === 1) {
-        return borderWithSpace;
+        return borderTwoSpaces;
       }
     }
     if (opts.type === "M_END" && opts.border && index === 0) {
-      return !opts.title ? "" : `${bar({ borderColor: opts.borderColor })}  ${line}`;
+      if (!opts.title) return "";
+      return `${bar({ borderColor: opts.borderColor })}  ${line}`;
     }
     if (!line.trim() || line.includes(symbols.middle)) {
       return line;
@@ -287,7 +266,7 @@ ${borderWithSpace}` : "",
     if (index === 0 && symbol) {
       return `${symbol}  ${line}`;
     }
-    return `${borderWithSpace}${line}`;
+    return `${config.prefix}${line}`;
   });
   if (opts.type === "M_END" && opts.border) {
     lines.push(`${prefixEndLine}${suffixEndLine}
@@ -300,8 +279,7 @@ ${borderWithSpace}` : "",
 const printedLineStack = [];
 export function msg(opts) {
   const { text, lineCount } = fmt(opts);
-  process.stdout.write(text + `
-`);
+  process.stdout.write(text + "\n");
   printedLineStack.push(lineCount + 1);
 }
 export function msgUndo(count = 1) {
@@ -322,8 +300,8 @@ export function msgUndoAll() {
 }
 export function printLineBar(text, indent = 2) {
   if (text === "") {
-    console.log(pc.dim("\u2502"));
-  } else {
-    console.log(`${pc.dim("\u2502")}${" ".repeat(indent)}${text}`);
+    console.log(re.dim("\u2502"));
+    return;
   }
+  console.log(`${re.dim("\u2502")}${" ".repeat(indent)}${text}`);
 }

package/dist-npm/components/messages/relico.d.ts

@@ -0,0 +1,80 @@
+import type { Static } from "@sinclair/typebox";
+/** The entire relico config */
+declare const RelicoConfigSchema: import("@sinclair/typebox").TObject<{
+    colorLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<0>, import("@sinclair/typebox").TLiteral<1>, import("@sinclair/typebox").TLiteral<2>, import("@sinclair/typebox").TLiteral<3>]>>;
+    customColors: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString, import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>]>>>;
+}>;
+export type RelicoConfig = Static<typeof RelicoConfigSchema>;
+type BaseColorMap = {
+    reset: [string, string];
+    bold: [string, string, string];
+    dim: [string, string, string];
+    italic: [string, string];
+    underline: [string, string];
+    inverse: [string, string];
+    hidden: [string, string];
+    strikethrough: [string, string];
+    black: [string, string];
+    red: [string, string];
+    green: [string, string];
+    yellow: [string, string];
+    blue: [string, string];
+    magenta: [string, string];
+    cyan: [string, string];
+    white: [string, string];
+    gray: [string, string];
+    bgBlack: [string, string];
+    bgRed: [string, string];
+    bgGreen: [string, string];
+    bgYellow: [string, string];
+    bgBlue: [string, string];
+    bgMagenta: [string, string];
+    bgCyan: [string, string];
+    bgWhite: [string, string];
+    blackBright: [string, string];
+    redBright: [string, string];
+    greenBright: [string, string];
+    yellowBright: [string, string];
+    blueBright: [string, string];
+    magentaBright: [string, string];
+    cyanBright: [string, string];
+    whiteBright: [string, string];
+    bgBlackBright: [string, string];
+    bgRedBright: [string, string];
+    bgGreenBright: [string, string];
+    bgYellowBright: [string, string];
+    bgBlueBright: [string, string];
+    bgMagentaBright: [string, string];
+    bgCyanBright: [string, string];
+    bgWhiteBright: [string, string];
+};
+/**
+ * Allows user to update the relico config at runtime.
+ */
+export declare function configure(userInput: unknown): void;
+/** Return a read-only copy of current config */
+export declare function getConfig(): RelicoConfig;
+/** Retrieve a specific color function by name (or fallback to reset) */
+export declare function getColor(name: string): (text: string | number) => string;
+/** Colorize text with a named color function */
+export declare function colorize(name: string, text: string | number): string;
+/** Force-set the color level (0=none,1=basic,2=256,3=truecolor) */
+export declare function setColorLevel(level: 0 | 1 | 2 | 3): void;
+/**
+ * If truecolor is available (and level=3),
+ * return a custom rgb(...) color function. Otherwise identity.
+ */
+export declare function rgb(r: number, g: number, b: number): (input: string | number) => string;
+/** Type for the re object with explicit color properties */
+type ReObject = {
+    [K in keyof BaseColorMap]: (text: string | number) => string;
+};
+/** Just a small proxy object returning the dynamic color functions */
+export declare const re: ReObject;
+export declare const colorSupport: {
+    isColorSupported: boolean;
+    isForced: boolean;
+    isDisabled: boolean;
+    terminalName: string;
+};
+export {};

package/dist-npm/components/messages/relico.js

@@ -0,0 +1,213 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { env, isWindows } from "std-env";
+import { getCurrentTerminalName } from "./platforms.js";
+const ColorDefinitionSchema = Type.Tuple([
+  Type.String(),
+  Type.String(),
+  Type.Optional(Type.String())
+]);
+const ColorMapSchema = Type.Record(Type.String(), ColorDefinitionSchema);
+const RelicoConfigSchema = Type.Object(
+  {
+    // The level of color support (0=none, 1=basic, 2=256, 3=truecolor)
+    colorLevel: Type.Optional(
+      Type.Union([
+        Type.Literal(0),
+        Type.Literal(1),
+        Type.Literal(2),
+        Type.Literal(3)
+      ])
+    ),
+    // An optional set of overrides or new color definitions
+    customColors: Type.Optional(ColorMapSchema)
+  },
+  { additionalProperties: false }
+);
+const defaultConfig = {
+  colorLevel: void 0,
+  customColors: void 0
+};
+const { argv = [] } = typeof process === "undefined" ? {} : process;
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+const isCompatibleTerminal = typeof process !== "undefined" && process.stdout && process.stdout.isTTY && env["TERM"] !== "dumb";
+const colorterm = (env["COLORTERM"] || "").toLowerCase();
+const supportsTrueColor = colorterm === "truecolor" || colorterm === "24bit";
+function detectColorLevel() {
+  if (isDisabled) return 0;
+  if (isForced) return 3;
+  if (supportsTrueColor) return 3;
+  if (isWindows) return 2;
+  if (isCI) return 2;
+  if (isCompatibleTerminal) {
+    return 2;
+  }
+  return 0;
+}
+const baseColors = {
+  // Reset
+  reset: ["\x1B[0m", "\x1B[0m"],
+  // Styles
+  bold: ["\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"],
+  dim: ["\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"],
+  italic: ["\x1B[3m", "\x1B[23m"],
+  underline: ["\x1B[4m", "\x1B[24m"],
+  inverse: ["\x1B[7m", "\x1B[27m"],
+  hidden: ["\x1B[8m", "\x1B[28m"],
+  strikethrough: ["\x1B[9m", "\x1B[29m"],
+  // Basic
+  black: ["\x1B[30m", "\x1B[39m"],
+  red: ["\x1B[31m", "\x1B[39m"],
+  green: ["\x1B[32m", "\x1B[39m"],
+  yellow: ["\x1B[33m", "\x1B[39m"],
+  blue: ["\x1B[34m", "\x1B[39m"],
+  magenta: ["\x1B[35m", "\x1B[39m"],
+  cyan: ["\x1B[36m", "\x1B[39m"],
+  white: ["\x1B[37m", "\x1B[39m"],
+  gray: ["\x1B[90m", "\x1B[39m"],
+  // Background
+  bgBlack: ["\x1B[40m", "\x1B[49m"],
+  bgRed: ["\x1B[41m", "\x1B[49m"],
+  bgGreen: ["\x1B[42m", "\x1B[49m"],
+  bgYellow: ["\x1B[43m", "\x1B[49m"],
+  bgBlue: ["\x1B[44m", "\x1B[49m"],
+  bgMagenta: ["\x1B[45m", "\x1B[49m"],
+  bgCyan: ["\x1B[46m", "\x1B[49m"],
+  bgWhite: ["\x1B[47m", "\x1B[49m"],
+  // Bright
+  blackBright: ["\x1B[90m", "\x1B[39m"],
+  redBright: ["\x1B[91m", "\x1B[39m"],
+  greenBright: ["\x1B[92m", "\x1B[39m"],
+  yellowBright: ["\x1B[93m", "\x1B[39m"],
+  blueBright: ["\x1B[94m", "\x1B[39m"],
+  magentaBright: ["\x1B[95m", "\x1B[39m"],
+  cyanBright: ["\x1B[96m", "\x1B[39m"],
+  whiteBright: ["\x1B[97m", "\x1B[39m"],
+  // Bright background
+  bgBlackBright: ["\x1B[100m", "\x1B[49m"],
+  bgRedBright: ["\x1B[101m", "\x1B[49m"],
+  bgGreenBright: ["\x1B[102m", "\x1B[49m"],
+  bgYellowBright: ["\x1B[103m", "\x1B[49m"],
+  bgBlueBright: ["\x1B[104m", "\x1B[49m"],
+  bgMagentaBright: ["\x1B[105m", "\x1B[49m"],
+  bgCyanBright: ["\x1B[106m", "\x1B[49m"],
+  bgWhiteBright: ["\x1B[107m", "\x1B[49m"]
+};
+const windowsTerminalColors = {
+  ...baseColors,
+  red: ["\x1B[38;2;255;85;85m", "\x1B[39m"],
+  green: ["\x1B[38;2;80;250;123m", "\x1B[39m"],
+  yellow: ["\x1B[38;2;241;250;140m", "\x1B[39m"],
+  blue: ["\x1B[38;2;98;114;164m", "\x1B[39m"],
+  magenta: ["\x1B[38;2;255;121;198m", "\x1B[39m"],
+  cyan: ["\x1B[38;2;139;233;253m", "\x1B[39m"]
+};
+function replaceClose(str, close, replace, index) {
+  let result = "", cursor = 0;
+  do {
+    result += str.substring(cursor, index) + replace;
+    cursor = index + close.length;
+    index = str.indexOf(close, cursor);
+  } while (~index);
+  return result + str.substring(cursor);
+}
+function createFormatter(open, close, replace = open) {
+  return (input) => {
+    const string = String(input);
+    const idx = string.indexOf(close, open.length);
+    return ~idx ? open + replaceClose(string, close, replace, idx) + close : open + string + close;
+  };
+}
+let _config = {
+  ...defaultConfig,
+  colorLevel: detectColorLevel()
+  // initial detect
+};
+let _colorMap = {};
+let _colorFunctions = {};
+function buildColorMap(cfg) {
+  const terminalName = getCurrentTerminalName();
+  const isWinTerm = terminalName === "Windows Terminal";
+  if (cfg.colorLevel === 0) {
+    const map = {};
+    Object.keys(baseColors).forEach((k) => {
+      map[k] = ["", "", ""];
+    });
+    return map;
+  }
+  const builtIn = isWinTerm && cfg.colorLevel === 3 ? { ...windowsTerminalColors } : { ...baseColors };
+  if (cfg.customColors) {
+    for (const [k, v] of Object.entries(cfg.customColors)) {
+      builtIn[k] = v;
+    }
+  }
+  return builtIn;
+}
+function initColorFunctions() {
+  _colorFunctions = {};
+  if (_config.colorLevel === 0) {
+    for (const k of Object.keys(baseColors)) {
+      _colorFunctions[k] = (text) => String(text);
+    }
+    return;
+  }
+  for (const [key, [open, close, replace]] of Object.entries(_colorMap)) {
+    _colorFunctions[key] = createFormatter(open, close, replace);
+  }
+}
+function rebuild() {
+  _colorMap = buildColorMap(_config);
+  initColorFunctions();
+}
+rebuild();
+export function configure(userInput) {
+  const newObj = typeof userInput === "object" && userInput !== null ? { ..._config, ...userInput } : { ..._config };
+  try {
+    const parsed = Value.Cast(RelicoConfigSchema, newObj);
+    _config = parsed;
+  } catch (err) {
+    console.warn("Invalid relico config:", err);
+    return;
+  }
+  rebuild();
+}
+export function getConfig() {
+  return { ..._config };
+}
+function identityColor(text) {
+  return String(text);
+}
+export function getColor(name) {
+  return _colorFunctions[name] || _colorFunctions["reset"] || identityColor;
+}
+export function colorize(name, text) {
+  const fn = getColor(name);
+  return fn(text);
+}
+export function setColorLevel(level) {
+  configure({ colorLevel: level });
+}
+export function rgb(r, g, b) {
+  if (_config.colorLevel === 3) {
+    const open = `\x1B[38;2;${r};${g};${b}m`;
+    const close = "\x1B[39m";
+    return createFormatter(open, close);
+  }
+  return identityColor;
+}
+export const re = new Proxy(
+  {},
+  {
+    get(_target, prop) {
+      return getColor(prop);
+    }
+  }
+);
+export const colorSupport = {
+  isColorSupported: getConfig().colorLevel !== 0,
+  isForced,
+  isDisabled,
+  terminalName: getCurrentTerminalName()
+};

package/dist-npm/components/reporters/fancy.js

@@ -2,7 +2,7 @@ import isUnicodeSupported from "is-unicode-supported";
 import stringWidth from "string-width";
 import { BasicReporter } from "../../components/reporters/basic.js";
 import { box } from "../../utils/box.js";
-import { colors } from "../../utils/color.js";
+import { colors } from "../../utils/deprecatedColors.js";
 import { parseStack } from "../../utils/error.js";
 import { stripAnsi } from "../../utils/string.js";
 export const TYPE_COLOR_MAP = {

package/dist-npm/utils/box.js

@@ -1,4 +1,4 @@
-import { getColor } from "./color.js";
+import { getColor } from "./deprecatedColors.js";
 import { stripAnsi } from "./string.js";
 const boxStylePresets = {
   solid: {

package/dist-npm/utils/mod.d.ts

@@ -1,3 +1,3 @@
 export * from "../utils/box.js";
-export * from "../utils/color.js";
+export * from "../utils/deprecatedColors.js";
 export { stripAnsi, centerAlign, rightAlign, leftAlign, align, } from "../utils/string.js";

package/dist-npm/utils/mod.js

@@ -1,5 +1,5 @@
 export * from "../utils/box.js";
-export * from "../utils/color.js";
+export * from "../utils/deprecatedColors.js";
 export {
   stripAnsi,
   centerAlign,

package/dist-npm/utils/tree.d.ts

@@ -1,4 +1,4 @@
-import { type ColorName } from "./color.js";
+import { type ColorName } from "./deprecatedColors.js";
 export type TreeItemObject = {
     /**
      * Text of the item

package/dist-npm/utils/tree.js

@@ -1,4 +1,4 @@
-import { colorize } from "./color.js";
+import { colorize } from "./deprecatedColors.js";
 export function formatTree(items, options) {
   options = {
     prefix: "  ",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reliverse/relinka",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "author": "blefnk",
   "type": "module",
   "description": "@reliverse/relinka is a powerful logger for your terminal.",
@@ -56,31 +56,34 @@
   "license": "MIT",
   "dependencies": {
     "@figliolia/chalk-animation": "^1.0.4",
-    "@sinclair/typebox": "^0.34.13",
+    "@reliverse/relico": "^1.0.0",
+    "@sinclair/typebox": "^0.34.14",
     "ansi-diff-stream": "^1.2.1",
     "ansi-escapes": "^7.0.0",
     "chalk": "^5.4.1",
     "cli-spinners": "^3.2.0",
     "cli-styles": "^1.0.0",
     "cli-width": "^4.1.0",
+    "confbox": "^0.1.8",
     "defu": "^6.1.4",
+    "destr": "^2.0.3",
     "detect-package-manager": "^3.0.2",
     "external-editor": "^3.1.0",
     "fast-glob": "^3.3.3",
     "figlet": "^1.8.0",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.3.0",
     "get-pixels": "^3.3.3",
     "globby": "^14.0.2",
     "gradient-string": "^3.0.0",
     "is-unicode-supported": "^2.1.0",
     "kleur": "^4.1.5",
     "log-update": "^6.1.0",
+    "mri": "^1.2.0",
     "mute-stream": "^2.0.0",
     "node-emoji": "^2.2.0",
-    "nypm": "^0.4.1",
+    "nypm": "^0.5.0",
     "ora": "^8.1.1",
-    "pathe": "^2.0.1",
-    "picocolors": "^1.1.1",
+    "pathe": "^2.0.2",
     "precision": "^1.0.1",
     "seventh": "^0.9.2",
     "signal-exit": "^4.1.0",
@@ -96,19 +99,19 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.3",
     "@biomejs/biome": "1.9.4",
-    "@cspell/dict-npm": "^5.1.22",
+    "@cspell/dict-npm": "^5.1.23",
     "@eslint/js": "^9.18.0",
-    "@eslint/json": "^0.9.0",
+    "@eslint/json": "^0.9.1",
     "@eslint/markdown": "^6.2.1",
     "@stylistic/eslint-plugin": "^2.13.0",
     "@types/ansi-diff-stream": "^1.2.3",
-    "@types/bun": "^1.1.16",
+    "@types/bun": "^1.1.18",
     "@types/chalk-animation": "^1.6.3",
     "@types/eslint__js": "^8.42.3",
     "@types/figlet": "^1.7.0",
     "@types/fs-extra": "^11.0.4",
     "@types/mute-stream": "^0.0.4",
-    "@types/node": "^22.10.6",
+    "@types/node": "^22.10.7",
     "@types/sentencer": "^0.2.3",
     "@types/signal-exit": "^3.0.4",
     "@types/strip-comments": "^2.0.4",
@@ -116,18 +119,18 @@
     "c12": "^2.0.1",
     "citty": "^0.1.6",
     "eslint": "^9.18.0",
-    "eslint-plugin-perfectionist": "^4.6.0",
+    "eslint-plugin-perfectionist": "^4.7.0",
     "execa": "^9.5.2",
     "jiti": "^2.4.2",
-    "knip": "^5.42.0",
+    "knip": "^5.42.3",
     "mock-stdin": "^1.0.0",
     "printj": "^1.3.1",
     "sentencer": "^0.2.1",
     "strip-comments": "^2.0.1",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.20.0",
+    "typescript-eslint": "^8.21.0",
     "unbuild": "^3.3.1",
-    "vitest": "^2.1.8"
+    "vitest": "^3.0.3"
   }
-}
+}