colorino 0.13.2 → 0.14.1

package/dist/{shared/colorino.vAejLjBp.mjs → cdn.mjs}

@@ -1,53 +1,5 @@
-function hexToRgb(hex) {
-  const match = hex.toString().match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
-  if (!match) {
-    return [0, 0, 0];
-  }
-  let colorString = match[0];
-  if (match[0].length === 3) {
-    colorString = [...colorString].map((char) => char + char).join("");
-  }
-  const integer = parseInt(colorString, 16);
-  const r = integer >> 16 & 255;
-  const g = integer >> 8 & 255;
-  const b = integer & 255;
-  return [r, g, b];
-}
-function rgbToAnsi256(rgb) {
-  const [r, g, b] = rgb;
-  if (r === g && g === b) {
-    if (r < 8) return 16;
-    if (r > 248) return 231;
-    return Math.round((r - 8) / 247 * 24) + 232;
-  }
-  return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
-}
-function rgbToHsvValue(rgb) {
-  const r = rgb[0] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[2] / 255;
-  const v = Math.max(r, g, b);
-  return v * 100;
-}
-function rgbToAnsi16(rgb) {
-  const [r, g, b] = rgb;
-  const value = rgbToHsvValue(rgb);
-  const roundedValue = Math.round(value / 50);
-  if (roundedValue === 0) {
-    return 30;
-  }
-  let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
-  if (roundedValue === 2) {
-    ansi += 60;
-  }
-  return ansi;
-}
-const colorConverter = {
-  hex: {
-    toRgb: hexToRgb,
-    toAnsi16: (hex) => rgbToAnsi16(hexToRgb(hex)),
-    toAnsi256: (hex) => rgbToAnsi256(hexToRgb(hex))
-  }};
+const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+const ColorinoBrowserObject = Symbol("colorino.browserObject");
 
 var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
   ColorLevel2[ColorLevel2["NO_COLOR"] = 0] = "NO_COLOR";
@@ -57,92 +9,6 @@ var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
   return ColorLevel2;
 })(ColorLevel || {});
 
-const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
-const ColorinoBrowserObject = Symbol("colorino.browserObject");
-
-const catppuccinMochaPalette = {
-  log: "#cdd6f4",
-  // Text
-  info: "#89b4fa",
-  // Blue
-  warn: "#f9e2af",
-  // Yellow
-  error: "#f38ba8",
-  // Red
-  debug: "#a6adc8",
-  // Subtext0
-  trace: "#9399b2"
-  // Subtext1
-};
-const catppuccinLattePalette = {
-  log: "#4c4f69",
-  // Text
-  info: "#1e66f5",
-  // Blue
-  warn: "#df8e1d",
-  // Yellow
-  error: "#d20f39",
-  // Red
-  debug: "#7c7f93",
-  // Subtext0
-  trace: "#8c8fa1"
-  // Subtext1
-};
-const draculaPalette = {
-  log: "#f8f8f2",
-  // Foreground
-  info: "#8be9fd",
-  // Cyan
-  warn: "#f1fa8c",
-  // Yellow
-  error: "#ff5555",
-  // Red
-  debug: "#bd93f9",
-  // Purple
-  trace: "#6272a4"
-  // Comment
-};
-const githubLightPalette = {
-  log: "#24292e",
-  // Text
-  info: "#0366d6",
-  // Blue
-  warn: "#f9a002",
-  // Yellow
-  error: "#d73a49",
-  // Red
-  debug: "#586069",
-  // Gray
-  trace: "#6a737d"
-  // Gray-light
-};
-
-const themePalettes = {
-  "catppuccin-mocha": catppuccinMochaPalette,
-  "catppuccin-latte": catppuccinLattePalette,
-  dracula: draculaPalette,
-  "github-light": githubLightPalette
-};
-const defaultDarkTheme = "dracula";
-const defaultLightTheme = "github-light";
-function isThemeName(theme) {
-  return theme in themePalettes;
-}
-
-function determineBaseTheme(themeOpt, detectedBrowserTheme) {
-  let baseThemeName;
-  if (isThemeName(themeOpt)) {
-    baseThemeName = themeOpt;
-  } else if (themeOpt === "light") {
-    baseThemeName = defaultLightTheme;
-  } else if (themeOpt === "dark") {
-    baseThemeName = defaultDarkTheme;
-  } else {
-    baseThemeName = detectedBrowserTheme === "light" ? defaultLightTheme : defaultDarkTheme;
-  }
-  return baseThemeName;
-}
-
 class TypeValidator {
   static isNull(value) {
     return value === null;
@@ -182,31 +48,18 @@ class TypeValidator {
   }
 }
 
-class MyColorino {
-  constructor(initialPalette, _userPalette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
+class AbstractColorino {
+  constructor(initialPalette, _userPalette, _validator, colorLevel, _options = {}) {
     this._userPalette = _userPalette;
     this._validator = _validator;
-    this._browserColorSupportDetector = _browserColorSupportDetector;
-    this._nodeColorSupportDetector = _nodeColorSupportDetector;
     this._options = _options;
     this._palette = initialPalette;
-    this.isBrowser = !!this._browserColorSupportDetector;
-    this._colorLevel = this._detectColorSupport();
     const validatePaletteResult = this._validator.validatePalette(this._palette);
     if (validatePaletteResult.isErr()) throw validatePaletteResult.error;
-    if (this._colorLevel !== ColorLevel.NO_COLOR && !this._options.disableWarnings && this._colorLevel === "UnknownEnv") {
-      this._maybeWarnUser();
-    }
-    const themeOpt = this._options.theme ?? "auto";
-    if (themeOpt === "auto" && this._nodeColorSupportDetector) {
-      this._nodeColorSupportDetector.onTheme((resolvedTheme) => {
-        this._applyResolvedTheme(resolvedTheme);
-      });
-    }
+    this._colorLevel = colorLevel;
   }
   _alreadyWarned = false;
   _colorLevel;
-  isBrowser;
   _palette;
   log(...args) {
     this._out("log", args);
@@ -230,7 +83,7 @@ class MyColorino {
     if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
       return text;
     }
-    if (this.isBrowser) {
+    if (this.isBrowser()) {
       return {
         [ColorinoBrowserColorized]: true,
         text,
@@ -243,37 +96,28 @@ class MyColorino {
     }
     return `${ansiPrefix}${text}\x1B[0m`;
   }
-  _applyResolvedTheme(resolvedTheme) {
-    const themeOpt = this._options.theme ?? "auto";
-    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
-    const basePalette = themePalettes[baseThemeName];
-    this._palette = { ...basePalette, ...this._userPalette };
-  }
-  _detectColorSupport() {
-    if (this.isBrowser) {
-      return this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
-    }
-    if (this._nodeColorSupportDetector?.isNodeEnv()) {
-      return this._nodeColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
+  _out(level, args) {
+    const consoleMethod = TypeValidator.isConsoleMethod(level) ? level : "log";
+    const processedArgs = this.processArgs(args);
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      this.output(consoleMethod, processedArgs);
+      return;
     }
-    return "UnknownEnv";
+    const coloredArgs = this.applyColors(consoleMethod, processedArgs);
+    this.output(consoleMethod, coloredArgs);
   }
-  _maybeWarnUser() {
-    if (this._alreadyWarned) return;
-    this._alreadyWarned = true;
-    console.warn(
-      "No ANSI color support detected in this terminal. See [https://github.com/chalk/supports-color#support-matrix](https://github.com/chalk/supports-color#support-matrix) to learn how to enable terminal color."
-    );
+  _toAnsiPrefix(_hex) {
+    return "";
   }
   _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
     const seen = /* @__PURE__ */ new WeakSet();
-    const sanitizeArray = (items, currentDepth) => {
-      return items.map((item) => sanitize(item, currentDepth));
+    const sanitizeArray = (items, depth) => {
+      return items.map((item) => sanitize(item, depth));
     };
-    const sanitizeObject = (obj, currentDepth) => {
+    const sanitizeObject = (obj, depth) => {
       const result = {};
       for (const key in obj) {
-        result[key] = sanitize(obj[key], currentDepth);
+        result[key] = sanitize(obj[key], depth);
       }
       return result;
     };
@@ -292,42 +136,34 @@ class MyColorino {
     };
     return JSON.stringify(sanitize(value, 0), null, 2);
   }
-  _processArgs(args) {
-    const processedArgs = [];
-    let previousWasObject = false;
-    for (const arg of args) {
-      if (TypeValidator.isBrowserColorizedArg(arg)) {
-        processedArgs.push(arg);
-        previousWasObject = false;
-        continue;
-      }
-      if (TypeValidator.isFormattableObject(arg)) {
-        if (this.isBrowser) {
-          processedArgs.push({
-            [ColorinoBrowserObject]: true,
-            value: arg
-          });
-        } else {
-          processedArgs.push(`
-${this._formatValue(arg)}`);
-        }
-        previousWasObject = true;
-      } else if (TypeValidator.isError(arg)) {
-        processedArgs.push("\n", this._cleanErrorStack(arg));
-        previousWasObject = true;
-      } else {
-        if (TypeValidator.isString(arg) && previousWasObject) {
-          processedArgs.push(`
-${arg}`);
-        } else {
-          processedArgs.push(arg);
-        }
-        previousWasObject = false;
-      }
+  _filterStack(stack) {
+    return stack.split("\n").filter((line) => !line.match(/.*colorino.*/gi)).join("\n");
+  }
+  _cleanErrorStack(error) {
+    if (!error.stack) return error;
+    const cleanStack = this._filterStack(error.stack);
+    const cloned = Object.create(Object.getPrototypeOf(error));
+    Object.assign(cloned, error);
+    cloned.stack = cleanStack;
+    return cloned;
+  }
+  _printCleanTrace(args) {
+    const error = new Error();
+    if (error.stack) {
+      const cleanStack = this._filterStack(error.stack);
+      console.log(...args, `
+${cleanStack}`);
+    } else {
+      console.log(...args);
     }
-    return processedArgs;
   }
-  _applyBrowserColors(consoleMethod, args) {
+}
+
+class ColorinoBrowser extends AbstractColorino {
+  constructor(initialPalette, userPalette, validator, colorLevel, options = {}) {
+    super(initialPalette, userPalette, validator, colorLevel, options);
+  }
+  applyColors(consoleMethod, args) {
     const formatParts = [];
     const cssArgs = [];
     const otherArgs = [];
@@ -351,80 +187,83 @@ ${arg}`);
       formatParts.push("%o");
       otherArgs.push(arg);
     }
-    if (formatParts.length === 0) {
-      return args;
-    }
+    if (formatParts.length === 0) return args;
     return [formatParts.join(""), ...cssArgs, ...otherArgs];
   }
-  _toAnsiPrefix(hex) {
-    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
-      return "";
-    }
-    switch (this._colorLevel) {
-      case ColorLevel.TRUECOLOR: {
-        const [r, g, b] = colorConverter.hex.toRgb(hex);
-        return `\x1B[38;2;${r};${g};${b}m`;
-      }
-      case ColorLevel.ANSI256: {
-        const code = colorConverter.hex.toAnsi256(hex);
-        return `\x1B[38;5;${code}m`;
+  output(consoleMethod, args) {
+    console[consoleMethod](...args);
+  }
+  processArgs(args) {
+    const processedArgs = [];
+    let previousWasObject = false;
+    for (const arg of args) {
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        processedArgs.push(arg);
+        previousWasObject = false;
+        continue;
       }
-      case ColorLevel.ANSI:
-      default: {
-        const code = colorConverter.hex.toAnsi16(hex);
-        return `\x1B[${code}m`;
+      if (TypeValidator.isFormattableObject(arg)) {
+        processedArgs.push({
+          [ColorinoBrowserObject]: true,
+          value: arg
+        });
+        previousWasObject = true;
+      } else if (TypeValidator.isError(arg)) {
+        processedArgs.push("\n", this._cleanErrorStack(arg));
+        previousWasObject = true;
+      } else {
+        processedArgs.push(
+          TypeValidator.isString(arg) && previousWasObject ? `
+${arg}` : arg
+        );
+        previousWasObject = false;
       }
     }
+    return processedArgs;
   }
-  _applyNodeColors(consoleMethod, args) {
-    const paletteHex = this._palette[consoleMethod];
-    const paletteAnsiPrefix = this._toAnsiPrefix(paletteHex);
-    if (!paletteAnsiPrefix) return args;
-    return args.map((arg) => {
-      if (!TypeValidator.isString(arg) || TypeValidator.isAnsiColoredString(arg))
-        return arg;
-      return `${paletteAnsiPrefix}${String(arg)}\x1B[0m`;
-    });
-  }
-  _output(consoleMethod, args) {
-    if (consoleMethod === "trace") this._printCleanTrace(args);
-    else console[consoleMethod](...args);
+  isBrowser() {
+    return true;
   }
-  _out(level, args) {
-    const consoleMethod = TypeValidator.isConsoleMethod(level) ? level : "log";
-    const processedArgs = this._processArgs(args);
-    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
-      this._output(consoleMethod, processedArgs);
-      return;
+}
+
+class BrowserColorSupportDetector {
+  constructor(_window, _navigator, _overrideTheme) {
+    this._window = _window;
+    this._navigator = _navigator;
+    this._overrideTheme = _overrideTheme;
+  }
+  isBrowserEnv() {
+    return !!this._window && !!this._navigator?.userAgent;
+  }
+  getColorLevel() {
+    const isTruecolor = window.matchMedia("(color-gamut: p3)").matches;
+    if (isTruecolor) {
+      return ColorLevel.TRUECOLOR;
     }
-    if (this.isBrowser) {
-      const coloredArgs2 = this._applyBrowserColors(consoleMethod, processedArgs);
-      this._output(consoleMethod, coloredArgs2);
-      return;
+    const isAnsi256 = window.matchMedia("(monochrome: 0)").matches;
+    if (isAnsi256) {
+      return ColorLevel.ANSI256;
     }
-    const coloredArgs = this._applyNodeColors(consoleMethod, processedArgs);
-    this._output(consoleMethod, coloredArgs);
-  }
-  _filterStack(stack) {
-    return stack.split("\n").filter((line) => !line.match(/.*colorino.*/gi)).join("\n");
+    return ColorLevel.ANSI;
   }
-  _cleanErrorStack(error) {
-    if (!error.stack) return error;
-    const cleanStack = this._filterStack(error.stack);
-    const cloned = Object.create(Object.getPrototypeOf(error));
-    Object.assign(cloned, error);
-    cloned.stack = cleanStack;
-    return cloned;
-  }
-  _printCleanTrace(args) {
-    const error = new Error();
-    if (error.stack) {
-      const cleanStack = this._filterStack(error.stack);
-      console.log(...args, `
-${cleanStack}`);
-    } else {
-      console.log(...args);
+  getTheme() {
+    if (this._overrideTheme) {
+      return this._overrideTheme;
+    }
+    if (!this.isBrowserEnv() || typeof this._window.matchMedia !== "function") {
+      return "unknown";
+    }
+    const isDarkTheme = this._window.matchMedia(
+      "(prefers-color-scheme: dark)"
+    ).matches;
+    if (isDarkTheme) {
+      return "dark";
+    }
+    const isLightTheme = "(prefers-color-scheme: light)";
+    if (this._window.matchMedia(isLightTheme).matches) {
+      return "light";
     }
+    return "unknown";
   }
 }
 
@@ -939,4 +778,115 @@ class InputValidator {
   }
 }
 
-export { ColorLevel as C, InputValidator as I, MyColorino as M, determineBaseTheme as d, themePalettes as t };
+const catppuccinMochaPalette = {
+  log: "#cdd6f4",
+  // Text
+  info: "#89b4fa",
+  // Blue
+  warn: "#f9e2af",
+  // Yellow
+  error: "#f38ba8",
+  // Red
+  debug: "#a6adc8",
+  // Subtext0
+  trace: "#9399b2"
+  // Subtext1
+};
+const catppuccinLattePalette = {
+  log: "#4c4f69",
+  // Text
+  info: "#1e66f5",
+  // Blue
+  warn: "#df8e1d",
+  // Yellow
+  error: "#d20f39",
+  // Red
+  debug: "#7c7f93",
+  // Subtext0
+  trace: "#8c8fa1"
+  // Subtext1
+};
+const draculaPalette = {
+  log: "#f8f8f2",
+  // Foreground
+  info: "#8be9fd",
+  // Cyan
+  warn: "#f1fa8c",
+  // Yellow
+  error: "#ff5555",
+  // Red
+  debug: "#bd93f9",
+  // Purple
+  trace: "#6272a4"
+  // Comment
+};
+const githubLightPalette = {
+  log: "#24292e",
+  // Text
+  info: "#0366d6",
+  // Blue
+  warn: "#f9a002",
+  // Yellow
+  error: "#d73a49",
+  // Red
+  debug: "#586069",
+  // Gray
+  trace: "#6a737d"
+  // Gray-light
+};
+
+const themePalettes = {
+  "catppuccin-mocha": catppuccinMochaPalette,
+  "catppuccin-latte": catppuccinLattePalette,
+  dracula: draculaPalette,
+  "github-light": githubLightPalette
+};
+const defaultDarkTheme = "dracula";
+const defaultLightTheme = "github-light";
+function isThemeName(theme) {
+  return theme in themePalettes;
+}
+
+function determineBaseTheme(themeOpt, detectedBrowserTheme) {
+  let baseThemeName;
+  if (isThemeName(themeOpt)) {
+    baseThemeName = themeOpt;
+  } else if (themeOpt === "light") {
+    baseThemeName = defaultLightTheme;
+  } else if (themeOpt === "dark") {
+    baseThemeName = defaultDarkTheme;
+  } else {
+    baseThemeName = detectedBrowserTheme === "light" ? defaultLightTheme : defaultDarkTheme;
+  }
+  return baseThemeName;
+}
+
+function createColorino(userPalette = {}, options = {}) {
+  const validator = new InputValidator();
+  let detectorThemeOverride;
+  if (options.theme === "dark" || options.theme === "light") {
+    detectorThemeOverride = options.theme;
+  }
+  const browserDetector = new BrowserColorSupportDetector(
+    window,
+    navigator,
+    detectorThemeOverride
+  );
+  const detectedBrowserTheme = browserDetector.getTheme();
+  const themeOpt = options.theme ?? "auto";
+  const baseThemeName = determineBaseTheme(themeOpt, detectedBrowserTheme);
+  const basePalette = themePalettes[baseThemeName];
+  const finalPalette = { ...basePalette, ...userPalette };
+  const colorLevel = browserDetector.isBrowserEnv() ? browserDetector.getColorLevel() ?? "UnknownEnv" : "UnknownEnv";
+  return new ColorinoBrowser(
+    finalPalette,
+    userPalette,
+    validator,
+    colorLevel,
+    options
+  );
+}
+const colorino = createColorino();
+
+export { colorino, createColorino, themePalettes };
+//# sourceMappingURL=cdn.mjs.map