style-logs 0.0.1 → 0.0.3

package/dist/index.js

@@ -17,83 +17,599 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  log: () => log
+// Structure/index.ts
+var Structure_exports = {};
+__export(Structure_exports, {
+  animate: () => animate,
+  log: () => log,
+  style: () => style
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(Structure_exports);
 
-// src/console.ts
-var import_common_tags = require("common-tags");
-var style = {
-  reset: "\x1B[0m",
-  styles: {
-    bold: "\x1B[1m",
-    dim: "\x1B[2m",
-    underline: "\x1B[4m",
-    inverse: "\x1B[7m",
-    hidden: "\x1B[8m"
-  },
-  fg: {
-    black: "\x1B[30m",
-    red: "\x1B[31m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    blue: "\x1B[34m",
-    magenta: "\x1B[35m",
-    cyan: "\x1B[36m",
-    white: "\x1B[37m",
-    crimson: "\x1B[38m",
-    orange: "\x1B[38;5;208m",
-    teal: "\x1B[38;5;6m"
-  },
-  bg: {
-    black: "\x1B[40m",
-    red: "\x1B[41m",
-    green: "\x1B[42m",
-    yellow: "\x1B[43m",
-    blue: "\x1B[44m",
-    magenta: "\x1B[45m",
-    cyan: "\x1B[46m",
-    white: "\x1B[47m",
-    crimson: "\x1B[48m",
-    orange: "\x1B[48;5;208m",
-    teal: "\x1B[48;5;6m"
+// Structure/ansi.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+var STYLES = {
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  italic: `${ESC}3m`,
+  underline: `${ESC}4m`,
+  inverse: `${ESC}7m`,
+  hidden: `${ESC}8m`,
+  strikethrough: `${ESC}9m`
+};
+var COLORS = {
+  black: `${ESC}30m`,
+  red: `${ESC}31m`,
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  blue: `${ESC}34m`,
+  magenta: `${ESC}35m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+  gray: `${ESC}90m`
+};
+var BG_COLORS = {
+  black: `${ESC}40m`,
+  red: `${ESC}41m`,
+  green: `${ESC}42m`,
+  yellow: `${ESC}43m`,
+  blue: `${ESC}44m`,
+  magenta: `${ESC}45m`,
+  cyan: `${ESC}46m`,
+  white: `${ESC}47m`,
+  gray: `${ESC}100m`
+};
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? [
+    parseInt(result[1], 16),
+    parseInt(result[2], 16),
+    parseInt(result[3], 16)
+  ] : null;
+}
+function rgbToAnsi(r, g, b, isBg = false) {
+  return `${ESC}${isBg ? 48 : 38};2;${r};${g};${b}m`;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function toHyperlink(url, text) {
+  return `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
+}
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+function interpolateColor(c1, c2, t) {
+  return [
+    Math.round(lerp(c1[0], c2[0], t)),
+    Math.round(lerp(c1[1], c2[1], t)),
+    Math.round(lerp(c1[2], c2[2], t))
+  ];
+}
+function sliceAnsi(str, length) {
+  let visible = 0;
+  let i = 0;
+  let inAnsi = false;
+  while (i < str.length) {
+    if (visible >= length && !inAnsi && str[i] !== "\x1B") break;
+    const char = str[i];
+    if (char === "\x1B") {
+      inAnsi = true;
+    } else if (inAnsi && char === "m") {
+      inAnsi = false;
+    } else if (!inAnsi) {
+      visible++;
+    }
+    i++;
+  }
+  return str.substring(0, i) + RESET;
+}
+function getStandardColorRgb(name) {
+  const map = {
+    black: [0, 0, 0],
+    red: [205, 49, 49],
+    green: [13, 188, 121],
+    yellow: [229, 229, 16],
+    blue: [36, 114, 200],
+    magenta: [188, 63, 188],
+    cyan: [17, 168, 205],
+    white: [229, 229, 229],
+    gray: [102, 102, 102]
+  };
+  return map[name] || null;
+}
+
+// Structure/parser.ts
+function parse(input) {
+  const root = { type: "block", children: [], styles: {} };
+  const stack = [root];
+  let current = 0;
+  while (current < input.length) {
+    const char = input[current];
+    if (char === "{") {
+      if (current > 0 && input[current - 1] === "\\") {
+        const last = stack[stack.length - 1].children[stack[stack.length - 1].children.length - 1];
+        if (last && last.type === "text") {
+          last.content += "{";
+        } else {
+          stack[stack.length - 1].children.push({ type: "text", content: "{" });
+        }
+        current++;
+        continue;
+      }
+      const endStyle = input.indexOf("}", current);
+      if (endStyle === -1) {
+        const last = stack[stack.length - 1].children[stack[stack.length - 1].children.length - 1];
+        if (last && last.type === "text") {
+          last.content += "{";
+        } else {
+          stack[stack.length - 1].children.push({ type: "text", content: "{" });
+        }
+        current++;
+        continue;
+      }
+      const styleStr = input.substring(current + 1, endStyle);
+      if (styleStr === "/") {
+        if (stack.length > 1) {
+          stack.pop();
+        }
+        current = endStyle + 1;
+        continue;
+      }
+      const styles = parseStyles(styleStr);
+      const newNode = { type: "block", styles, children: [] };
+      stack[stack.length - 1].children.push(newNode);
+      stack.push(newNode);
+      current = endStyle + 1;
+    } else {
+      let nextTag = input.indexOf("{", current);
+      if (nextTag === -1) nextTag = input.length;
+      while (nextTag > 0 && input[nextTag - 1] === "\\") {
+        const nextRealTag = input.indexOf("{", nextTag + 1);
+        if (nextRealTag === -1) {
+          nextTag = input.length;
+          break;
+        }
+        nextTag = nextRealTag;
+      }
+      let text = input.substring(current, nextTag);
+      text = text.replace(/\\{/g, "{");
+      if (text) {
+        stack[stack.length - 1].children.push({ type: "text", content: text });
+      }
+      current = nextTag;
+    }
+  }
+  return root.children || [];
+}
+function parseStyles(styleStr) {
+  const styles = {};
+  const parts = styleStr.split(";").map((s) => s.trim()).filter((s) => s);
+  for (const part of parts) {
+    if (part.includes(":")) {
+      let key, val;
+      if (part.startsWith("link:")) {
+        key = "link";
+        val = part.substring(5).trim();
+      } else {
+        [key, val] = part.split(":").map((s) => s.trim());
+      }
+      if (key === "color") styles.color = val;
+      if (key === "bg") styles.bg = val;
+      if (key === "link") styles.link = val;
+      if (key === "badge") styles.badge = val;
+      if (key === "border") styles.border = val;
+      if (key === "gradient") {
+        styles.gradient = val.split(",").map((s) => s.trim());
+      }
+    } else {
+      if (part === "bold") styles.bold = true;
+      if (part === "dim") styles.dim = true;
+      if (part === "italic") styles.italic = true;
+      if (part === "underline") styles.underline = true;
+      if (part === "inverse") styles.inverse = true;
+      if (part === "hidden") styles.hidden = true;
+      if (part === "strikethrough") styles.strikethrough = true;
+      if (part === "rainbow") styles.rainbow = true;
+      if (part === "border" || part === "box") styles.border = true;
+    }
+  }
+  return styles;
+}
+function render(nodes, parentStyles = {}, options = {}) {
+  let output = "";
+  for (const node of nodes) {
+    if (node.type === "text") {
+      output += applyStyles(node.content, parentStyles);
+    } else if (node.type === "block") {
+      const mergedStyles = { ...parentStyles, ...node.styles };
+      let content = "";
+      if (mergedStyles.gradient || mergedStyles.rainbow) {
+        const textContent = getTextContent(node.children || []);
+        content = applyGradient(textContent, mergedStyles, options);
+      } else {
+        content = render(node.children || [], mergedStyles, options);
+      }
+      if (mergedStyles.border) {
+        content = applyBorder(content, mergedStyles.border);
+      }
+      output += content;
+    }
+  }
+  return output;
+}
+function getTextContent(nodes) {
+  let text = "";
+  for (const node of nodes) {
+    if (node.type === "text") text += node.content;
+    else if (node.type === "block") text += getTextContent(node.children || []);
+  }
+  return text;
+}
+function applyStyles(text, styles) {
+  let start = "";
+  let end = RESET;
+  if (styles.bold) start += STYLES.bold;
+  if (styles.dim) start += STYLES.dim;
+  if (styles.italic) start += STYLES.italic;
+  if (styles.underline) start += STYLES.underline;
+  if (styles.inverse) start += STYLES.inverse;
+  if (styles.hidden) start += STYLES.hidden;
+  if (styles.strikethrough) start += STYLES.strikethrough;
+  if (styles.badge) {
+    const badgeStyles = getBadgeStyles(styles.badge);
+    if (badgeStyles.bg) start += badgeStyles.bg;
+    if (badgeStyles.color) start += badgeStyles.color;
+    text = ` ${text} `;
+  }
+  if (styles.color && !styles.badge) {
+    if (COLORS[styles.color]) start += COLORS[styles.color];
+    else {
+      const rgb = hexToRgb(styles.color);
+      if (rgb) start += rgbToAnsi(rgb[0], rgb[1], rgb[2]);
+    }
+  }
+  if (styles.bg && !styles.badge) {
+    if (BG_COLORS[styles.bg]) start += BG_COLORS[styles.bg];
+    else {
+      const rgb = hexToRgb(styles.bg);
+      if (rgb) start += rgbToAnsi(rgb[0], rgb[1], rgb[2], true);
+    }
+  }
+  if (styles.link) {
+    return start + toHyperlink(styles.link, text) + end;
+  }
+  return start + text + end;
+}
+function applyGradient(text, styles, options = {}) {
+  if (styles.rainbow) {
+    return applyRainbow(text, styles, options);
+  }
+  if (!styles.gradient || styles.gradient.length < 2) return text;
+  const startColorName = styles.gradient[0];
+  const endColorName = styles.gradient[1];
+  let c1 = hexToRgb(startColorName);
+  if (!c1 && COLORS[startColorName]) {
+    c1 = getStandardColorRgb(startColorName);
+  }
+  let c2 = hexToRgb(endColorName);
+  if (!c2 && COLORS[endColorName]) {
+    c2 = getStandardColorRgb(endColorName);
+  }
+  if (!c1 || !c2) return text;
+  let output = "";
+  const len = text.length;
+  const offset = options.gradientOffset || 0;
+  for (let i = 0; i < len; i++) {
+    const t = (Math.sin((i / (len || 1) + offset) * Math.PI * 2) + 1) / 2;
+    const [r, g, b] = interpolateColor(c1, c2, t);
+    let charStyle = "";
+    if (styles.bold) charStyle += STYLES.bold;
+    charStyle += rgbToAnsi(r, g, b);
+    output += charStyle + text[i];
   }
+  return output + RESET;
+}
+function applyRainbow(text, styles, options = {}) {
+  const rainbowColors = [
+    [255, 0, 0],
+    // Red
+    [255, 127, 0],
+    // Orange
+    [255, 255, 0],
+    // Yellow
+    [0, 255, 0],
+    // Green
+    [0, 0, 255],
+    // Blue
+    [75, 0, 130],
+    // Indigo
+    [148, 0, 211]
+    // Violet
+  ];
+  let output = "";
+  const len = text.length;
+  const offset = options.rainbowOffset || 0;
+  for (let i = 0; i < len; i++) {
+    const t = (i + offset) / (len || 1) * (rainbowColors.length - 1);
+    const wrappedT = t % (rainbowColors.length - 1);
+    const index = Math.floor(wrappedT);
+    const nextIndex = (index + 1) % rainbowColors.length;
+    const factor = wrappedT - index;
+    const c1 = rainbowColors[index];
+    const c2 = rainbowColors[nextIndex];
+    const [r, g, b] = interpolateColor(c1, c2, factor);
+    let charStyle = "";
+    if (styles.bold) charStyle += STYLES.bold;
+    if (styles.italic) charStyle += STYLES.italic;
+    if (styles.underline) charStyle += STYLES.underline;
+    charStyle += rgbToAnsi(r, g, b);
+    output += charStyle + text[i];
+  }
+  return output + RESET;
+}
+function getBadgeStyles(type) {
+  const map = {
+    info: { bg: BG_COLORS.blue, color: COLORS.white },
+    success: { bg: BG_COLORS.green, color: COLORS.black },
+    warning: { bg: BG_COLORS.yellow, color: COLORS.black },
+    error: { bg: BG_COLORS.red, color: COLORS.white }
+  };
+  return map[type] || { bg: BG_COLORS.gray, color: COLORS.white };
+}
+function applyBorder(content, style2) {
+  const lines = content.split("\n");
+  const cleanLines = lines.map((l) => stripAnsi(l));
+  const maxWidth = Math.max(...cleanLines.map((l) => l.length));
+  const color = typeof style2 === "string" && COLORS[style2] ? COLORS[style2] : "";
+  const reset = typeof style2 === "string" && COLORS[style2] ? RESET : "";
+  const top = "\u250C" + "\u2500".repeat(maxWidth + 2) + "\u2510";
+  const bottom = "\u2514" + "\u2500".repeat(maxWidth + 2) + "\u2518";
+  let output = "\n" + color + top + reset + "\n";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const clean = cleanLines[i];
+    const padding = " ".repeat(maxWidth - clean.length);
+    output += color + "\u2502 " + reset + line + padding + color + " \u2502" + reset + "\n";
+  }
+  output += color + bottom + reset + "\n";
+  return output;
+}
+
+// Structure/animation.ts
+var SPINNERS = {
+  line: ["|", "/", "-", "\\"],
+  circle: ["\u25DC", "\u25E0", "\u25DD", "\u25DE", "\u25E1", "\u25DF"],
+  dots: [".", "..", "..."],
+  bounce: ["\u2801", "\u2802", "\u2804", "\u2802"],
+  spin: ["\u283F", "\u2837", "\u282F", "\u281F", "\u283B"],
+  pulse: ["\u25CF\u25CB\u25CB", "\u25CB\u25CF\u25CB", "\u25CB\u25CB\u25CF", "\u25CB\u25CF\u25CB"],
+  quarter: ["\u25D0", "\u25D3", "\u25D1", "\u25D2"],
+  clock: ["\u25F4", "\u25F7", "\u25F6", "\u25F5"],
+  square: ["\u2B12", "\u2B14", "\u2B13", "\u2B15"],
+  bar: ["\u25B1\u25B1\u25B1", "\u25B0\u25B1\u25B1", "\u25B0\u25B0\u25B1", "\u25B0\u25B0\u25B0"],
+  hourglass: ["\u29D6", "\u29D7"]
 };
-var log = (text) => {
-  const regex = /<text\s*(.*?)>(.*?)<\/text>/gs;
-  let result = "";
-  const lines = (0, import_common_tags.stripIndents)(text).split("\n");
-  lines.forEach((line) => {
-    let processedLine = line;
-    let match;
-    while ((match = regex.exec(line)) !== null) {
-      const attributes = match[1].trim();
-      const content = match[2];
-      let colorCode = style.reset;
-      if (attributes) {
-        const attributeRegex = /(f|b|s)-(\w+)/g;
-        let attrMatch;
-        while ((attrMatch = attributeRegex.exec(attributes)) !== null) {
-          const [, type, styleName] = attrMatch;
-          if (type === "f" && style.fg[styleName]) {
-            colorCode += style.fg[styleName];
-          } else if (type === "b" && style.bg[styleName]) {
-            colorCode += style.bg[styleName];
-          } else if (type === "s" && style.styles[styleName]) {
-            colorCode += style.styles[styleName];
+var animate = {
+  typewriter: (text, speedOrOptions = 30) => {
+    const options = typeof speedOrOptions === "number" ? { speed: speedOrOptions } : speedOrOptions;
+    const speed = options.speed || 30;
+    const loop = options.loop || false;
+    const styled = style(text);
+    const plain = stripAnsi(styled);
+    const len = plain.length;
+    let interval;
+    let stopped = false;
+    const promise = new Promise((resolve) => {
+      const start = () => {
+        let i = 0;
+        interval = setInterval(() => {
+          if (stopped) {
+            clearInterval(interval);
+            resolve();
+            return;
+          }
+          i++;
+          process.stdout.write("\r" + sliceAnsi(styled, i));
+          if (i >= len) {
+            if (loop) {
+              clearInterval(interval);
+              setTimeout(() => {
+                if (!stopped) {
+                  process.stdout.write("\r\x1B[2K");
+                  start();
+                } else {
+                  resolve();
+                }
+              }, 1e3);
+            } else {
+              clearInterval(interval);
+              process.stdout.write("\n");
+              resolve();
+            }
           }
+        }, speed);
+      };
+      start();
+    });
+    promise.stop = () => {
+      stopped = true;
+      if (interval) clearInterval(interval);
+    };
+    return promise;
+  },
+  gradient: (text, durationOrOptions = 2e3) => {
+    const options = typeof durationOrOptions === "number" ? { duration: durationOrOptions } : durationOrOptions;
+    const duration = options.duration || 2e3;
+    const loop = options.loop || false;
+    let input = text;
+    if (!text.includes("{gradient")) {
+      input = `{gradient: red, blue}${text}{/}`;
+    }
+    const astToRender = parse(input);
+    let offset = 0;
+    const startTime = Date.now();
+    let interval;
+    let stopped = false;
+    const promise = new Promise((resolve) => {
+      interval = setInterval(() => {
+        if (stopped) {
+          clearInterval(interval);
+          process.stdout.write("\n");
+          resolve();
+          return;
+        }
+        const elapsed = Date.now() - startTime;
+        if (!loop && elapsed > duration) {
+          clearInterval(interval);
+          process.stdout.write("\n");
+          resolve();
+          return;
+        }
+        offset += 0.02;
+        const output = render(astToRender, {}, { gradientOffset: offset });
+        process.stdout.write("\r" + output);
+      }, 50);
+    });
+    promise.stop = () => {
+      stopped = true;
+    };
+    return promise;
+  },
+  glitch: (text, durationOrOptions = 2e3) => {
+    const options = typeof durationOrOptions === "number" ? { duration: durationOrOptions } : durationOrOptions;
+    const duration = options.duration || 2e3;
+    const loop = options.loop || false;
+    const styled = style(text);
+    const plain = stripAnsi(styled);
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
+    const len = plain.length;
+    const startTime = Date.now();
+    let interval;
+    let stopped = false;
+    const promise = new Promise((resolve) => {
+      interval = setInterval(() => {
+        if (stopped) {
+          clearInterval(interval);
+          process.stdout.write("\r" + styled + "\n");
+          resolve();
+          return;
+        }
+        const elapsed = Date.now() - startTime;
+        if (!loop && elapsed > duration) {
+          clearInterval(interval);
+          process.stdout.write("\r" + styled + "\n");
+          resolve();
+          return;
+        }
+        let glitchText = "";
+        for (let i = 0; i < len; i++) {
+          if (Math.random() > 0.5 || plain[i] === " ") {
+            glitchText += plain[i];
+          } else {
+            glitchText += chars[Math.floor(Math.random() * chars.length)];
+          }
+        }
+        process.stdout.write("\r" + glitchText);
+      }, 50);
+    });
+    promise.stop = () => {
+      stopped = true;
+    };
+    return promise;
+  },
+  thinking: (text, durationOrPromise = 2e3, colorOrOptions = "cyan") => {
+    let color = "cyan";
+    let frames = SPINNERS.circle;
+    if (typeof colorOrOptions === "string") {
+      color = colorOrOptions;
+    } else {
+      color = colorOrOptions.color || color;
+      if (colorOrOptions.frames) {
+        if (Array.isArray(colorOrOptions.frames)) {
+          frames = colorOrOptions.frames;
+        } else if (typeof colorOrOptions.frames === "string" && SPINNERS[colorOrOptions.frames]) {
+          frames = SPINNERS[colorOrOptions.frames];
         }
       }
-      processedLine = processedLine.replace(match[0], `${colorCode}${content}${style.reset}`);
     }
-    result += processedLine + "\n";
-  });
-  console.log(result.trim());
+    let frameIndex = 0;
+    const styled = style(text);
+    let interval;
+    return new Promise((resolve) => {
+      interval = setInterval(() => {
+        const frame = frames[frameIndex = (frameIndex + 1) % frames.length];
+        process.stdout.write("\r" + style(`{color: ${color}}${frame}{/} `) + styled);
+      }, 80);
+      if (typeof durationOrPromise === "number") {
+        setTimeout(() => {
+          clearInterval(interval);
+          process.stdout.write("\r\x1B[2K");
+          resolve();
+        }, durationOrPromise);
+      } else {
+        durationOrPromise.then(() => {
+          clearInterval(interval);
+          process.stdout.write("\r\x1B[2K");
+          resolve();
+        });
+      }
+    });
+  },
+  stream: (text, minSpeed = 10, maxSpeed = 50) => {
+    const styled = style(text);
+    const plain = stripAnsi(styled);
+    const len = plain.length;
+    let stopped = false;
+    let timeout;
+    const promise = new Promise((resolve) => {
+      let i = 0;
+      const nextChar = () => {
+        if (stopped) {
+          process.stdout.write("\n");
+          resolve();
+          return;
+        }
+        i++;
+        process.stdout.write("\r" + sliceAnsi(styled, i));
+        if (i >= len) {
+          process.stdout.write("\n");
+          resolve();
+        } else {
+          const delay = Math.floor(Math.random() * (maxSpeed - minSpeed + 1)) + minSpeed;
+          timeout = setTimeout(nextChar, delay);
+        }
+      };
+      nextChar();
+    });
+    promise.stop = () => {
+      stopped = true;
+      if (timeout) clearTimeout(timeout);
+    };
+    return promise;
+  }
 };
+
+// Structure/index.ts
+function style(input) {
+  const ast = parse(input);
+  return render(ast);
+}
+function log(args, ...values) {
+  if (typeof args === "string") {
+    console.log(style(args));
+  } else {
+    let input = "";
+    args.forEach((str, i) => {
+      input += str + (values[i] !== void 0 ? values[i] : "");
+    });
+    console.log(style(input));
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  log
+  animate,
+  log,
+  style
 });