@bamboocss/logger 1.11.1

package/LICENSE.md

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2023 Segun Adebayo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.js

@@ -0,0 +1,274 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  colors: () => import_kleur2.default,
+  logger: () => logger,
+  quote: () => quote
+});
+module.exports = __toCommonJS(index_exports);
+var import_kleur2 = __toESM(require("kleur"));
+
+// src/create-logger.ts
+var import_kleur = __toESM(require("kleur"));
+
+// ../../node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+
+// ../../node_modules/.pnpm/matcher@6.0.0/node_modules/matcher/index.js
+var regexpCache = /* @__PURE__ */ new Map();
+var sanitizeArray = (input, inputName) => {
+  if (!Array.isArray(input)) {
+    switch (typeof input) {
+      case "string": {
+        input = [input];
+        break;
+      }
+      case "undefined": {
+        input = [];
+        break;
+      }
+      default: {
+        throw new TypeError(`Expected '${inputName}' to be a string or an array, but got a type of '${typeof input}'`);
+      }
+    }
+  }
+  return input.filter((string) => {
+    if (typeof string !== "string") {
+      if (string === void 0) {
+        return false;
+      }
+      throw new TypeError(`Expected '${inputName}' to be an array of strings, but found a type of '${typeof string}' in the array`);
+    }
+    return true;
+  });
+};
+var makeRegexp = (pattern, options) => {
+  options = {
+    caseSensitive: false,
+    ...options
+  };
+  const flags = "s" + (options.caseSensitive ? "" : "i");
+  const cacheKey = pattern + "|" + flags;
+  if (regexpCache.has(cacheKey)) {
+    return regexpCache.get(cacheKey);
+  }
+  const negated = pattern[0] === "!";
+  if (negated) {
+    pattern = pattern.slice(1);
+  }
+  pattern = pattern.replaceAll(String.raw`\*`, "__ESCAPED_STAR__").replaceAll("\\\\", "__ESCAPED_BACKSLASH__").replaceAll(/\\(.)/g, "$1");
+  pattern = escapeStringRegexp(pattern).replaceAll(String.raw`\*`, ".*");
+  pattern = pattern.replaceAll("__ESCAPED_STAR__", String.raw`\*`).replaceAll("__ESCAPED_BACKSLASH__", "\\\\");
+  const regexp = new RegExp(`^${pattern}$`, flags);
+  regexp.negated = negated;
+  regexpCache.set(cacheKey, regexp);
+  return regexp;
+};
+var baseMatcher = (inputs, patterns, options, firstMatchOnly) => {
+  inputs = sanitizeArray(inputs, "inputs");
+  patterns = sanitizeArray(patterns, "patterns");
+  if (patterns.length === 0) {
+    return [];
+  }
+  patterns = patterns.map((pattern) => makeRegexp(pattern, options));
+  const negatedPatterns = patterns.filter((pattern) => pattern.negated);
+  const positivePatterns = patterns.filter((pattern) => !pattern.negated);
+  const { allPatterns } = options || {};
+  const result = [];
+  if (allPatterns && firstMatchOnly && negatedPatterns.length > 1 && positivePatterns.length === 0) {
+    for (const input of inputs) {
+      for (const pattern of negatedPatterns) {
+        if (pattern.test(input)) {
+          return [];
+        }
+      }
+    }
+    return inputs.slice(0, 1);
+  }
+  for (const input of inputs) {
+    let excludedByNegation = false;
+    for (const pattern of negatedPatterns) {
+      if (pattern.test(input)) {
+        excludedByNegation = true;
+        break;
+      }
+    }
+    if (excludedByNegation) {
+      continue;
+    }
+    if (positivePatterns.length === 0) {
+      result.push(input);
+    } else if (allPatterns) {
+      const matchedPositive = Array.from({ length: positivePatterns.length }, () => false);
+      for (const [index, pattern] of positivePatterns.entries()) {
+        if (pattern.test(input)) {
+          matchedPositive[index] = true;
+        }
+      }
+      if (matchedPositive.every(Boolean)) {
+        result.push(input);
+      }
+    } else {
+      let matchedAny = false;
+      for (const pattern of positivePatterns) {
+        if (pattern.test(input)) {
+          matchedAny = true;
+          break;
+        }
+      }
+      if (matchedAny) {
+        result.push(input);
+      }
+    }
+    if (firstMatchOnly && result.length > 0) {
+      break;
+    }
+  }
+  return result;
+};
+function isMatch(inputs, patterns, options) {
+  return baseMatcher(inputs, patterns, options, true).length > 0;
+}
+
+// src/create-logger.ts
+var createLogger = (conf = {}) => {
+  let onLog = conf.onLog;
+  let level = conf.isDebug ? "debug" : conf.level ?? "info";
+  const filter = conf.filter !== "*" ? conf.filter?.split(/[\s,]+/) ?? [] : [];
+  const getLevel = () => filter.length ? "debug" : level;
+  const isValid = (level2, type) => {
+    const badLevel = logLevels[getLevel()].weight > logLevels[level2].weight;
+    const badType = filter.length > 0 && !matches(filter, type);
+    return !(badType || badLevel);
+  };
+  const stdout = (level2) => (type, data) => {
+    const entry = createEntry(level2, type, data);
+    if (level2 != null && isValid(level2, type)) {
+      const logEntry = formatEntry(entry) ?? {};
+      console.log(logEntry.label, logEntry.msg);
+    } else if (getLevel() !== "silent" && level2 == null) {
+      console.log(...[type, data].filter(Boolean));
+    }
+    onLog?.(entry);
+  };
+  const logFns = {
+    debug: stdout("debug"),
+    info: stdout("info"),
+    warn: stdout("warn"),
+    error: stdout("error")
+  };
+  const timing = (level2) => (msg) => {
+    const start = performance.now();
+    return (_msg = msg) => {
+      const end = performance.now();
+      const ms = end - start;
+      logFns[level2]("hrtime", `${_msg} ${import_kleur.default.gray(`(${ms.toFixed(2)}ms)`)}`);
+    };
+  };
+  const caughtError = (type, context, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    logFns.error(type, `${context}: ${message}`);
+    if (error instanceof Error && error.stack) {
+      logFns.debug(type, error.stack);
+    }
+  };
+  return {
+    get level() {
+      return level;
+    },
+    set level(newLevel) {
+      level = newLevel;
+    },
+    set onLog(fn) {
+      onLog = fn;
+    },
+    ...logFns,
+    caughtError,
+    print(data) {
+      console.dir(data, { depth: null, colors: true });
+    },
+    log: (data) => stdout(null)("", data),
+    time: {
+      info: timing("info"),
+      debug: timing("debug")
+    },
+    isDebug: Boolean(conf.isDebug)
+  };
+};
+var matches = (filters, value) => filters.some((search) => isMatch(value, search));
+var createEntry = (level, type, data) => {
+  const msg = data instanceof Error ? import_kleur.default.red(data.stack ?? data.message) : data;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return { t: timestamp, type, level, msg };
+};
+var formatEntry = (entry) => {
+  const uword = entry.type ? import_kleur.default.gray(`[${entry.type}]`) : "";
+  let label = "";
+  let msg = "";
+  if (entry.level != null) {
+    const { msg: message, level } = entry;
+    const color = logLevels[level].color;
+    const levelLabel = import_kleur.default.bold(color(`${level}`));
+    label = [`\u{1F43C}`, levelLabel, uword].filter(Boolean).join(" ");
+    msg = message;
+  } else {
+    label = uword ?? "";
+    msg = entry.msg;
+  }
+  return { label, msg };
+};
+var logLevels = {
+  debug: { weight: 0, color: import_kleur.default.magenta },
+  info: { weight: 1, color: import_kleur.default.blue },
+  warn: { weight: 2, color: import_kleur.default.yellow },
+  error: { weight: 3, color: import_kleur.default.red },
+  silent: { weight: 4, color: import_kleur.default.white }
+};
+
+// src/index.ts
+var quote = (...str) => import_kleur2.default.cyan(`\`${str.join("")}\``);
+var debug = typeof process !== "undefined" ? process.env.BAMBOO_DEBUG : void 0;
+var logger = createLogger({
+  filter: typeof process !== "undefined" ? debug : void 0,
+  isDebug: Boolean(debug)
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  colors,
+  logger,
+  quote
+});

package/dist/index.mjs

@@ -0,0 +1,237 @@
+// src/index.ts
+import colors2 from "kleur";
+
+// src/create-logger.ts
+import colors from "kleur";
+
+// ../../node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+
+// ../../node_modules/.pnpm/matcher@6.0.0/node_modules/matcher/index.js
+var regexpCache = /* @__PURE__ */ new Map();
+var sanitizeArray = (input, inputName) => {
+  if (!Array.isArray(input)) {
+    switch (typeof input) {
+      case "string": {
+        input = [input];
+        break;
+      }
+      case "undefined": {
+        input = [];
+        break;
+      }
+      default: {
+        throw new TypeError(`Expected '${inputName}' to be a string or an array, but got a type of '${typeof input}'`);
+      }
+    }
+  }
+  return input.filter((string) => {
+    if (typeof string !== "string") {
+      if (string === void 0) {
+        return false;
+      }
+      throw new TypeError(`Expected '${inputName}' to be an array of strings, but found a type of '${typeof string}' in the array`);
+    }
+    return true;
+  });
+};
+var makeRegexp = (pattern, options) => {
+  options = {
+    caseSensitive: false,
+    ...options
+  };
+  const flags = "s" + (options.caseSensitive ? "" : "i");
+  const cacheKey = pattern + "|" + flags;
+  if (regexpCache.has(cacheKey)) {
+    return regexpCache.get(cacheKey);
+  }
+  const negated = pattern[0] === "!";
+  if (negated) {
+    pattern = pattern.slice(1);
+  }
+  pattern = pattern.replaceAll(String.raw`\*`, "__ESCAPED_STAR__").replaceAll("\\\\", "__ESCAPED_BACKSLASH__").replaceAll(/\\(.)/g, "$1");
+  pattern = escapeStringRegexp(pattern).replaceAll(String.raw`\*`, ".*");
+  pattern = pattern.replaceAll("__ESCAPED_STAR__", String.raw`\*`).replaceAll("__ESCAPED_BACKSLASH__", "\\\\");
+  const regexp = new RegExp(`^${pattern}$`, flags);
+  regexp.negated = negated;
+  regexpCache.set(cacheKey, regexp);
+  return regexp;
+};
+var baseMatcher = (inputs, patterns, options, firstMatchOnly) => {
+  inputs = sanitizeArray(inputs, "inputs");
+  patterns = sanitizeArray(patterns, "patterns");
+  if (patterns.length === 0) {
+    return [];
+  }
+  patterns = patterns.map((pattern) => makeRegexp(pattern, options));
+  const negatedPatterns = patterns.filter((pattern) => pattern.negated);
+  const positivePatterns = patterns.filter((pattern) => !pattern.negated);
+  const { allPatterns } = options || {};
+  const result = [];
+  if (allPatterns && firstMatchOnly && negatedPatterns.length > 1 && positivePatterns.length === 0) {
+    for (const input of inputs) {
+      for (const pattern of negatedPatterns) {
+        if (pattern.test(input)) {
+          return [];
+        }
+      }
+    }
+    return inputs.slice(0, 1);
+  }
+  for (const input of inputs) {
+    let excludedByNegation = false;
+    for (const pattern of negatedPatterns) {
+      if (pattern.test(input)) {
+        excludedByNegation = true;
+        break;
+      }
+    }
+    if (excludedByNegation) {
+      continue;
+    }
+    if (positivePatterns.length === 0) {
+      result.push(input);
+    } else if (allPatterns) {
+      const matchedPositive = Array.from({ length: positivePatterns.length }, () => false);
+      for (const [index, pattern] of positivePatterns.entries()) {
+        if (pattern.test(input)) {
+          matchedPositive[index] = true;
+        }
+      }
+      if (matchedPositive.every(Boolean)) {
+        result.push(input);
+      }
+    } else {
+      let matchedAny = false;
+      for (const pattern of positivePatterns) {
+        if (pattern.test(input)) {
+          matchedAny = true;
+          break;
+        }
+      }
+      if (matchedAny) {
+        result.push(input);
+      }
+    }
+    if (firstMatchOnly && result.length > 0) {
+      break;
+    }
+  }
+  return result;
+};
+function isMatch(inputs, patterns, options) {
+  return baseMatcher(inputs, patterns, options, true).length > 0;
+}
+
+// src/create-logger.ts
+var createLogger = (conf = {}) => {
+  let onLog = conf.onLog;
+  let level = conf.isDebug ? "debug" : conf.level ?? "info";
+  const filter = conf.filter !== "*" ? conf.filter?.split(/[\s,]+/) ?? [] : [];
+  const getLevel = () => filter.length ? "debug" : level;
+  const isValid = (level2, type) => {
+    const badLevel = logLevels[getLevel()].weight > logLevels[level2].weight;
+    const badType = filter.length > 0 && !matches(filter, type);
+    return !(badType || badLevel);
+  };
+  const stdout = (level2) => (type, data) => {
+    const entry = createEntry(level2, type, data);
+    if (level2 != null && isValid(level2, type)) {
+      const logEntry = formatEntry(entry) ?? {};
+      console.log(logEntry.label, logEntry.msg);
+    } else if (getLevel() !== "silent" && level2 == null) {
+      console.log(...[type, data].filter(Boolean));
+    }
+    onLog?.(entry);
+  };
+  const logFns = {
+    debug: stdout("debug"),
+    info: stdout("info"),
+    warn: stdout("warn"),
+    error: stdout("error")
+  };
+  const timing = (level2) => (msg) => {
+    const start = performance.now();
+    return (_msg = msg) => {
+      const end = performance.now();
+      const ms = end - start;
+      logFns[level2]("hrtime", `${_msg} ${colors.gray(`(${ms.toFixed(2)}ms)`)}`);
+    };
+  };
+  const caughtError = (type, context, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    logFns.error(type, `${context}: ${message}`);
+    if (error instanceof Error && error.stack) {
+      logFns.debug(type, error.stack);
+    }
+  };
+  return {
+    get level() {
+      return level;
+    },
+    set level(newLevel) {
+      level = newLevel;
+    },
+    set onLog(fn) {
+      onLog = fn;
+    },
+    ...logFns,
+    caughtError,
+    print(data) {
+      console.dir(data, { depth: null, colors: true });
+    },
+    log: (data) => stdout(null)("", data),
+    time: {
+      info: timing("info"),
+      debug: timing("debug")
+    },
+    isDebug: Boolean(conf.isDebug)
+  };
+};
+var matches = (filters, value) => filters.some((search) => isMatch(value, search));
+var createEntry = (level, type, data) => {
+  const msg = data instanceof Error ? colors.red(data.stack ?? data.message) : data;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return { t: timestamp, type, level, msg };
+};
+var formatEntry = (entry) => {
+  const uword = entry.type ? colors.gray(`[${entry.type}]`) : "";
+  let label = "";
+  let msg = "";
+  if (entry.level != null) {
+    const { msg: message, level } = entry;
+    const color = logLevels[level].color;
+    const levelLabel = colors.bold(color(`${level}`));
+    label = [`\u{1F43C}`, levelLabel, uword].filter(Boolean).join(" ");
+    msg = message;
+  } else {
+    label = uword ?? "";
+    msg = entry.msg;
+  }
+  return { label, msg };
+};
+var logLevels = {
+  debug: { weight: 0, color: colors.magenta },
+  info: { weight: 1, color: colors.blue },
+  warn: { weight: 2, color: colors.yellow },
+  error: { weight: 3, color: colors.red },
+  silent: { weight: 4, color: colors.white }
+};
+
+// src/index.ts
+var quote = (...str) => colors2.cyan(`\`${str.join("")}\``);
+var debug = typeof process !== "undefined" ? process.env.BAMBOO_DEBUG : void 0;
+var logger = createLogger({
+  filter: typeof process !== "undefined" ? debug : void 0,
+  isDebug: Boolean(debug)
+});
+export {
+  colors2 as colors,
+  logger,
+  quote
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@bamboocss/logger",
+  "version": "1.11.1",
+  "description": "The core css bamboo library",
+  "homepage": "https://bamboo-css.com",
+  "license": "MIT",
+  "author": "Segun Adebayo <joseshegs@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chakra-ui/bamboo.git",
+    "directory": "packages/logger"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "kleur": "4.1.5",
+    "@bamboocss/types": "1.11.1"
+  },
+  "devDependencies": {
+    "matcher": "6.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format=esm,cjs --dts",
+    "build-fast": "tsup src/index.ts --format=esm,cjs --no-dts",
+    "dev": "pnpm build-fast --watch"
+  }
+}