summit-marker 2.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "summit-marker",
-  "version": "2.0.0",
+  "version": "3.0.2",
   "description": "Marker a zero-dependency Chalk alternative for Node.js with terminal colors, chaining, RGB, hex colors, gradients, and styled messages.",
   "type": "module",
   "main": "src/index.js",
@@ -32,7 +32,7 @@
     "summit"
   ],
   "author": "Summit",
-  "license": "UNLICENSED",
+  "license": "EULA",
   "scripts": {
     "test": "node test.js"
   },

package/src/backgrounds.js

@@ -0,0 +1,16 @@
+export const backgrounds = {
+  bgBlack: "\x1b[40m",
+  bgRed: "\x1b[41m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bgBlue: "\x1b[44m",
+  bgPurple: "\x1b[45m",
+  bgCyan: "\x1b[46m",
+  bgWhite: "\x1b[47m",
+
+  bgGray: "\x1b[100m"
+};
+
+export function bgRgb(r, g, b) {
+  return `\x1b[48;2;${r};${g};${b}m`;
+}

package/src/box.js

@@ -0,0 +1,73 @@
+export default function box(text, options = {}) {
+  const {
+    padding = 1,
+    border = "single"
+  } = options;
+
+  const borders = {
+    single: {
+      top: "─",
+      bottom: "─",
+      left: "│",
+      right: "│",
+      tl: "┌",
+      tr: "┐",
+      bl: "└",
+      br: "┘"
+    },
+
+    double: {
+      top: "═",
+      bottom: "═",
+      left: "║",
+      right: "║",
+      tl: "╔",
+      tr: "╗",
+      bl: "╚",
+      br: "╝"
+    },
+
+    round: {
+      top: "─",
+      bottom: "─",
+      left: "│",
+      right: "│",
+      tl: "╭",
+      tr: "╮",
+      bl: "╰",
+      br: "╯"
+    }
+  };
+
+  const style = borders[border] || borders.single;
+
+  const lines = String(text).split("\n");
+
+  const width =
+    Math.max(...lines.map(line => line.length)) +
+    padding * 2;
+
+  const top =
+    style.tl +
+    style.top.repeat(width) +
+    style.tr;
+
+  const bottom =
+    style.bl +
+    style.bottom.repeat(width) +
+    style.br;
+
+  const middle = lines.map(line =>
+    style.left +
+    " ".repeat(padding) +
+    line +
+    " ".repeat(width - line.length - padding) +
+    style.right
+  );
+
+  return [
+    top,
+    ...middle,
+    bottom
+  ].join("\n");
+}

package/src/colors.js

@@ -6,7 +6,7 @@ export const colors = {
   purple: "\x1b[35m",
   cyan: "\x1b[36m",
   white: "\x1b[37m",
-  grey: "\x1b[90m",
+  gray: "\x1b[90m",
   black: "\x1b[30m",
 
   orange: "\x1b[38;5;208m",

package/src/errors.js

@@ -0,0 +1,34 @@
+export default function error(options = {}) {
+    const {
+        title = "Error",
+        message = "",
+        code = null,
+        details = null
+    } = options;
+
+    let output = [];
+
+    output.push(
+        `✖ ${title}`
+    );
+
+    if (message) {
+        output.push(
+            `\n${message}`
+        );
+    }
+
+    if (code) {
+        output.push(
+            `\nCode: ${code}`
+        );
+    }
+
+    if (details) {
+        output.push(
+            `\nDetails:\n${details}`
+        );
+    }
+
+    return output.join("");
+}

package/src/gradients.js

@@ -0,0 +1,84 @@
+// src/gradients.js
+
+function createGradient(colors) {
+  return (text) => {
+    let output = "";
+
+    for (let i = 0; i < text.length; i++) {
+      const color = colors[i % colors.length];
+
+      output += `\x1b[38;5;${color}m${text[i]}`;
+    }
+
+    return `${output}\x1b[0m`;
+  };
+}
+
+export const gradients = {
+  rainbow: createGradient([
+    196,
+    208,
+    226,
+    46,
+    51,
+    21,
+    129
+  ]),
+
+  sunset: createGradient([
+    129,
+    198,
+    208,
+    226
+  ]),
+
+  ocean: createGradient([
+    51,
+    45,
+    39,
+    33
+  ]),
+
+  fire: createGradient([
+    196,
+    202,
+    208,
+    226
+  ]),
+
+  neon: createGradient([
+    201,
+    207,
+    51,
+    87
+  ]),
+
+  candy: createGradient([
+    213,
+    207,
+    201,
+    51
+  ]),
+
+  forest: createGradient([
+    22,
+    28,
+    34,
+    82
+  ]),
+
+  ice: createGradient([
+    231,
+    195,
+    159,
+    45
+  ]),
+
+  space: createGradient([
+    17,
+    54,
+    93,
+    129,
+    57
+  ])
+};

package/src/index.js

@@ -1,8 +1,26 @@
+import spinner from "./spinner.js";
+import table from "./table.js";
+import logger from "./logger.js";
+import { createThemes } from "./themes.js";
+import { backgrounds, bgRgb } from "./backgrounds.js";
+import { text } from "./text.js";
+import box from "./box.js";
 import { colors, styles, rgb, hex } from "./colors.js";
 import { apply } from "./styles.js";
-import { messages } from "./messages.js";
+import { messages, symbols } from "./messages.js";
+import { gradients } from "./gradients.js";
+import { rgbGradient } from "./rgbGradient.js";
 
 const marker = {};
+marker.logger = logger;
+marker.table = table;
+marker.spinner = spinner;
+
+const chainStyles = {
+  ...colors,
+  ...styles,
+  ...backgrounds
+};
 
 function createChain(codes = []) {
   const builder = (text) => {
@@ -13,10 +31,7 @@ function createChain(codes = []) {
     return apply(codes, text);
   };
 
-  for (const [name, code] of Object.entries({
-    ...colors,
-    ...styles
-  })) {
+  for (const [name, code] of Object.entries(chainStyles)) {
     Object.defineProperty(builder, name, {
       get() {
         return createChain([
@@ -30,10 +45,7 @@ function createChain(codes = []) {
   return builder;
 }
 
-for (const [name, code] of Object.entries({
-  ...colors,
-  ...styles
-})) {
+for (const [name, code] of Object.entries(chainStyles)) {
   Object.defineProperty(marker, name, {
     get() {
       return createChain([code]);
@@ -41,14 +53,32 @@ for (const [name, code] of Object.entries({
   });
 }
 
+
+// RGB foreground
 marker.rgb = (r, g, b) => {
-  return createChain([rgb(r, g, b)]);
+  return createChain([
+    rgb(r, g, b)
+  ]);
 };
 
+
+// HEX foreground
 marker.hex = (value) => {
-  return createChain([hex(value)]);
+  return createChain([
+    hex(value)
+  ]);
+};
+
+
+// RGB background
+marker.bgRgb = (r, g, b) => {
+  return createChain([
+    bgRgb(r, g, b)
+  ]);
 };
 
+
+// 256 color gradient
 marker.gradient = (text) => {
   if (marker.level === 0) {
     return text;
@@ -63,14 +93,42 @@ marker.gradient = (text) => {
   let output = "";
 
   for (let i = 0; i < text.length; i++) {
-    output += `\x1b[38;5;${palette[i % palette.length]}m${text[i]}`;
+    output +=
+      `\x1b[38;5;${palette[i % palette.length]}m${text[i]}`;
   }
 
   return `${output}\x1b[0m`;
 };
 
+
+// True RGB gradient
+marker.rgbGradient = rgbGradient;
+
+
+// Gradient presets
+marker.gradients = gradients;
+
+
+// Box formatting
+marker.box = box;
+
+
+// Messages
 Object.assign(marker, messages);
 
+
+// Symbols
+marker.symbols = symbols;
+
+
+// Text utilities
+Object.assign(marker, text);
+
+
+// Themes
+marker.themes = createThemes(marker);
+
+
 function getColorLevel() {
   if (process.env.NO_COLOR) {
     return 0;
@@ -91,7 +149,10 @@ function getColorLevel() {
   return 1;
 }
 
+
 marker.level = getColorLevel();
+
 marker.supportsColor = marker.level > 0;
 
+
 export default marker;

package/src/logger.js

@@ -0,0 +1,65 @@
+import { symbols } from "./messages.js";
+
+function timestamp() {
+  return new Date().toLocaleTimeString();
+}
+
+function format(level, message, symbol) {
+  return `${symbol} [${timestamp()}] ${level}: ${message}`;
+}
+
+export const logger = {
+  info(message) {
+    console.log(
+      format(
+        "INFO",
+        message,
+        symbols.info || "ℹ"
+      )
+    );
+  },
+
+  success(message) {
+    console.log(
+      format(
+        "SUCCESS",
+        message,
+        symbols.success || "✔"
+      )
+    );
+  },
+
+  warn(message) {
+    console.log(
+      format(
+        "WARN",
+        message,
+        symbols.warning || "⚠"
+      )
+    );
+  },
+
+  error(message) {
+    console.log(
+      format(
+        "ERROR",
+        message,
+        symbols.error || "✖"
+      )
+    );
+  },
+
+  debug(message) {
+    if (process.env.MARKER_DEBUG) {
+      console.log(
+        format(
+          "DEBUG",
+          message,
+          "🐛"
+        )
+      );
+    }
+  }
+};
+
+export default logger;

package/src/messages.js

@@ -1,20 +1,55 @@
 import { colors } from "./colors.js";
 import { apply } from "./styles.js";
 
+export const symbols = {
+  success: "✔",
+  error: "✖",
+  warning: "⚠",
+  info: "ℹ",
+
+  check: "✓",
+  cross: "✗",
+
+  bullet: "•",
+  dot: "·",
+
+  arrowRight: "→",
+  arrowLeft: "←",
+  arrowUp: "↑",
+  arrowDown: "↓",
+
+  plus: "+",
+  minus: "-",
+  star: "*",
+
+  pointer: ">",
+  pipe: "|",
+
+  loading: "⟳",
+
+  progress: "#",
+  empty: "-",
+
+  block: "█",
+  lightBlock: "░",
+  mediumBlock: "▒",
+  darkBlock: "▓"
+};
+
 export const messages = {
   success(text) {
-    return apply(colors.green, `✔ ${text}`);
+    return apply(colors.green, `${symbols.success} ${text}`);
   },
 
   error(text) {
-    return apply(colors.red, `✖ ${text}`);
+    return apply(colors.red, `${symbols.error} ${text}`);
   },
 
   warning(text) {
-    return apply(colors.yellow, `⚠ ${text}`);
+    return apply(colors.yellow, `${symbols.warning} ${text}`);
   },
 
   info(text) {
-    return apply(colors.blue, `ℹ ${text}`);
+    return apply(colors.blue, `${symbols.info} ${text}`);
   }
 };

package/src/progress.js

@@ -0,0 +1,67 @@
+export function progress(options = {}) {
+  const {
+    total = 100,
+    label = "Progress",
+    width = 20
+  } = options;
+
+  let current = 0;
+  let finished = false;
+
+  function render() {
+    if (finished) return;
+
+    const percent = Math.min(
+      Math.floor((current / total) * 100),
+      100
+    );
+
+    const filled = Math.floor(
+      (percent / 100) * width
+    );
+
+    const empty = width - filled;
+
+    const bar =
+      "█".repeat(filled) +
+      "░".repeat(empty);
+
+    process.stdout.write(
+      `\r${label} ${bar} ${current}/${total} ${percent}%`
+    );
+  }
+
+  function update(value) {
+    current = Math.min(value, total);
+    render();
+
+    if (current >= total) {
+      complete();
+    }
+  }
+
+  function increment(amount = 1) {
+    update(current + amount);
+  }
+
+  function complete() {
+    current = total;
+    render();
+    process.stdout.write("\n");
+    finished = true;
+  }
+
+  function stop() {
+    process.stdout.write("\n");
+    finished = true;
+  }
+
+  render();
+
+  return {
+    update,
+    increment,
+    complete,
+    stop
+  };
+}

package/src/rgbGradient.js

@@ -0,0 +1,48 @@
+// src/rgbGradient.js
+
+function interpolate(start, end, factor) {
+  return Math.round(
+    start + (end - start) * factor
+  );
+}
+
+function rgbCode(r, g, b) {
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+export function rgbGradient(start, end) {
+  return (text) => {
+    let output = "";
+
+    for (let i = 0; i < text.length; i++) {
+      const factor =
+        text.length <= 1
+          ? 0
+          : i / (text.length - 1);
+
+      const r = interpolate(
+        start[0],
+        end[0],
+        factor
+      );
+
+      const g = interpolate(
+        start[1],
+        end[1],
+        factor
+      );
+
+      const b = interpolate(
+        start[2],
+        end[2],
+        factor
+      );
+
+      output +=
+        rgbCode(r, g, b) +
+        text[i];
+    }
+
+    return `${output}\x1b[0m`;
+  };
+}

package/src/spinner.js

@@ -0,0 +1,83 @@
+const frames = [
+  "⠋",
+  "⠙",
+  "⠹",
+  "⠸",
+  "⠼",
+  "⠴",
+  "⠦",
+  "⠧",
+  "⠇",
+  "⠏"
+];
+
+export default function spinner(message = "Loading") {
+  let interval = null;
+  let index = 0;
+  let active = false;
+
+  function render(frame) {
+    process.stdout.write(
+      `\r${frame} ${message}`
+    );
+  }
+
+  return {
+
+    start() {
+      if (active) return;
+
+      active = true;
+
+      interval = setInterval(() => {
+        render(frames[index]);
+
+        index++;
+
+        if (index >= frames.length) {
+          index = 0;
+        }
+
+      }, 80);
+    },
+
+
+    stop(finalMessage = message) {
+      if (!active) return;
+
+      clearInterval(interval);
+      interval = null;
+      active = false;
+
+      process.stdout.write(
+        `\r  ${finalMessage}\n`
+      );
+    },
+
+
+    success(finalMessage = "Done") {
+      if (interval) {
+        clearInterval(interval);
+      }
+
+      active = false;
+
+      process.stdout.write(
+        `\r✔ ${finalMessage}\n`
+      );
+    },
+
+
+    error(finalMessage = "Failed") {
+      if (interval) {
+        clearInterval(interval);
+      }
+
+      active = false;
+
+      process.stdout.write(
+        `\r✖ ${finalMessage}\n`
+      );
+    }
+  };
+}