@pandacss/logger 0.0.0-dev-20221121152823

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 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.d.ts

@@ -0,0 +1,68 @@
+import colors from 'kleur';
+export { default as colors } from 'kleur';
+
+declare const levelsMap: {
+    debug: {
+        w: number;
+        c: colors.Color;
+    };
+    info: {
+        w: number;
+        c: colors.Color;
+    };
+    warn: {
+        w: number;
+        c: colors.Color;
+    };
+    error: {
+        w: number;
+        c: colors.Color;
+    };
+    silent: {
+        w: number;
+        c: colors.Color;
+    };
+};
+declare type LogLevel = keyof typeof levelsMap;
+declare type Config = {
+    level?: LogLevel;
+    defaults?: any;
+    only?: string[];
+    except?: string[];
+};
+declare type Entry = {
+    type: string;
+    level: LogLevel;
+    time: Date;
+    pid: number;
+    msg: string;
+    err?: Error | string;
+    [key: string]: any;
+};
+declare class Logger {
+    level: LogLevel;
+    only: string[];
+    except: string[];
+    defaults: any;
+    parsers: any;
+    constructor(conf?: Config);
+    addParser(key: string, parser: (data: any) => any): void;
+    private getEntry;
+    format(entry: Entry): string;
+    private parseErr;
+    private isValid;
+    private stdout;
+    warn(...args: any[]): any;
+    info(...args: any[]): any;
+    debug(...args: any[]): any;
+    error(...args: any[]): any;
+    log(...args: any[]): void;
+    get time(): {
+        info: (msg: string, ...args: any[]) => () => void;
+        debug: (msg: string, ...args: any[]) => () => void;
+    };
+}
+declare const logger: Logger;
+declare function quote(...str: string[]): string;
+
+export { Config, LogLevel, logger, quote };

package/dist/index.js

@@ -0,0 +1,262 @@
+"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(
+  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 src_exports = {};
+__export(src_exports, {
+  colors: () => import_kleur.default,
+  logger: () => logger,
+  quote: () => quote
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../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@5.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 (typeof string === "undefined") {
+        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 cacheKey = pattern + JSON.stringify(options);
+  if (regexpCache.has(cacheKey)) {
+    return regexpCache.get(cacheKey);
+  }
+  const negated = pattern[0] === "!";
+  if (negated) {
+    pattern = pattern.slice(1);
+  }
+  pattern = escapeStringRegexp(pattern).replace(/\\\*/g, "[\\s\\S]*");
+  const regexp = new RegExp(`^${pattern}$`, options.caseSensitive ? "" : "i");
+  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 { allPatterns } = options || {};
+  const result = [];
+  for (const input of inputs) {
+    let matches2;
+    const didFit = [...patterns].fill(false);
+    for (const [index, pattern] of patterns.entries()) {
+      if (pattern.test(input)) {
+        didFit[index] = true;
+        matches2 = !pattern.negated;
+        if (!matches2) {
+          break;
+        }
+      }
+    }
+    if (!(matches2 === false || matches2 === void 0 && patterns.some((pattern) => !pattern.negated) || allPatterns && didFit.some((yes, index) => !yes && !patterns[index].negated))) {
+      result.push(input);
+      if (firstMatchOnly) {
+        break;
+      }
+    }
+  }
+  return result;
+};
+function isMatch(inputs, patterns, options) {
+  return baseMatcher(inputs, patterns, options, true).length > 0;
+}
+
+// src/index.ts
+var import_kleur = __toESM(require("kleur"));
+var import_util = __toESM(require("util"));
+var omitKeys = ["level", "type", "time", "pid"];
+function compact(obj) {
+  const res = {};
+  for (const key in obj) {
+    if (!omitKeys.includes(key) && obj[key] != null) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+var levelsMap = {
+  debug: { w: 0, c: import_kleur.default.magenta },
+  info: { w: 1, c: import_kleur.default.blue },
+  warn: { w: 2, c: import_kleur.default.yellow },
+  error: { w: 3, c: import_kleur.default.red },
+  silent: { w: 4, c: import_kleur.default.white }
+};
+function matches(filters, value) {
+  return filters.some((search) => isMatch(value, search));
+}
+var Logger = class {
+  level;
+  only = [];
+  except = [];
+  defaults;
+  parsers;
+  constructor(conf = {}) {
+    const debugEnv = process.env.PANDA_DEBUG;
+    this.level = debugEnv ? "debug" : conf.level || "info";
+    const only = conf.only ?? debugEnv;
+    if (only && only !== "*") {
+      this.only = Array.isArray(only) ? only : only.split(/[\s,]+/);
+    }
+    if (conf.except) {
+      this.except = conf.except;
+    }
+    this.defaults = conf.defaults || {};
+    this.parsers = { err: this.parseErr };
+  }
+  addParser(key, parser) {
+    this.parsers[key] = parser;
+  }
+  getEntry(level, args) {
+    const data = typeof args[0] == "object" ? args.shift() : {};
+    let msg = import_util.default.format(...args);
+    const pid = process.pid != 1 ? process.pid : null;
+    for (const key in this.parsers) {
+      if (key in data) {
+        Object.assign(data, this.parsers[key](data));
+      }
+    }
+    msg = msg || data.msg;
+    return { level, ...data, msg, pid, time: new Date() };
+  }
+  format(entry) {
+    entry.time.setMinutes(entry.time.getMinutes() - entry.time.getTimezoneOffset());
+    const data = compact(entry);
+    const formatted = typeof entry.msg == "string" ? entry.msg : import_util.default.inspect(data, { colors: true, depth: null });
+    const uword = entry.type ? import_kleur.default.gray(`[${entry.type}]`) : void 0;
+    if (!entry.level) {
+      return [uword, formatted].filter(Boolean).join(" ");
+    }
+    const color = levelsMap[entry.level].c;
+    const label = import_kleur.default.bold(color(`${entry.level}`));
+    const msg = [`\u{1F43C}`, label, uword, formatted].filter(Boolean).join(" ");
+    return msg;
+  }
+  parseErr({ err }) {
+    if (!(err instanceof Error))
+      err = new Error(err);
+    const stack = err.stack.split(/[\r\n]+\s*/g);
+    return {
+      err: null,
+      code: err.code,
+      class: err.constructor.name,
+      stack: stack.slice(1, -1),
+      type: err.constructor.name,
+      msg: import_kleur.default.red(err.message)
+    };
+  }
+  isValid(level, type) {
+    const badLevel = levelsMap[this.level].w > levelsMap[level].w;
+    const badType = matches(this.except, type) || this.only.length > 0 && !matches(this.only, type);
+    return !(badType || badLevel);
+  }
+  stdout(level, ...args) {
+    const baseEntry = this.getEntry(level, args);
+    const entry = { ...this.defaults, ...baseEntry };
+    const valid = this.isValid(level, entry.type);
+    if (!valid)
+      return false;
+    const msg = this.format(entry);
+    console.log(msg);
+    return entry;
+  }
+  warn(...args) {
+    return this.stdout("warn", ...args);
+  }
+  info(...args) {
+    return this.stdout("info", ...args);
+  }
+  debug(...args) {
+    return this.stdout("debug", ...args);
+  }
+  error(...args) {
+    return this.stdout("error", ...args);
+  }
+  log(...args) {
+    const entry = this.getEntry(null, args);
+    if (this.level === "silent")
+      return;
+    console.log(this.format(entry));
+  }
+  get time() {
+    const base = (level, msg, ...args) => {
+      const str = `${msg} ${args.join(" ")}`;
+      const start = process.hrtime();
+      return () => {
+        const end = process.hrtime(start);
+        const ms = end[0] * 1e3 + end[1] * 1e-6;
+        this.stdout(level, { type: "hrtime", msg: `${str} ${import_kleur.default.gray(`(${ms.toFixed(2)}ms)`)}` });
+      };
+    };
+    return {
+      info: (msg, ...args) => base("info", msg, ...args),
+      debug: (msg, ...args) => base("debug", msg, ...args)
+    };
+  }
+};
+var logger = new Logger();
+function quote(...str) {
+  return import_kleur.default.cyan(`\`${str.join("")}\``);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  colors,
+  logger,
+  quote
+});

package/dist/index.mjs

@@ -0,0 +1,227 @@
+// ../../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@5.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 (typeof string === "undefined") {
+        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 cacheKey = pattern + JSON.stringify(options);
+  if (regexpCache.has(cacheKey)) {
+    return regexpCache.get(cacheKey);
+  }
+  const negated = pattern[0] === "!";
+  if (negated) {
+    pattern = pattern.slice(1);
+  }
+  pattern = escapeStringRegexp(pattern).replace(/\\\*/g, "[\\s\\S]*");
+  const regexp = new RegExp(`^${pattern}$`, options.caseSensitive ? "" : "i");
+  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 { allPatterns } = options || {};
+  const result = [];
+  for (const input of inputs) {
+    let matches2;
+    const didFit = [...patterns].fill(false);
+    for (const [index, pattern] of patterns.entries()) {
+      if (pattern.test(input)) {
+        didFit[index] = true;
+        matches2 = !pattern.negated;
+        if (!matches2) {
+          break;
+        }
+      }
+    }
+    if (!(matches2 === false || matches2 === void 0 && patterns.some((pattern) => !pattern.negated) || allPatterns && didFit.some((yes, index) => !yes && !patterns[index].negated))) {
+      result.push(input);
+      if (firstMatchOnly) {
+        break;
+      }
+    }
+  }
+  return result;
+};
+function isMatch(inputs, patterns, options) {
+  return baseMatcher(inputs, patterns, options, true).length > 0;
+}
+
+// src/index.ts
+import colors from "kleur";
+import util from "util";
+var omitKeys = ["level", "type", "time", "pid"];
+function compact(obj) {
+  const res = {};
+  for (const key in obj) {
+    if (!omitKeys.includes(key) && obj[key] != null) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+var levelsMap = {
+  debug: { w: 0, c: colors.magenta },
+  info: { w: 1, c: colors.blue },
+  warn: { w: 2, c: colors.yellow },
+  error: { w: 3, c: colors.red },
+  silent: { w: 4, c: colors.white }
+};
+function matches(filters, value) {
+  return filters.some((search) => isMatch(value, search));
+}
+var Logger = class {
+  level;
+  only = [];
+  except = [];
+  defaults;
+  parsers;
+  constructor(conf = {}) {
+    const debugEnv = process.env.PANDA_DEBUG;
+    this.level = debugEnv ? "debug" : conf.level || "info";
+    const only = conf.only ?? debugEnv;
+    if (only && only !== "*") {
+      this.only = Array.isArray(only) ? only : only.split(/[\s,]+/);
+    }
+    if (conf.except) {
+      this.except = conf.except;
+    }
+    this.defaults = conf.defaults || {};
+    this.parsers = { err: this.parseErr };
+  }
+  addParser(key, parser) {
+    this.parsers[key] = parser;
+  }
+  getEntry(level, args) {
+    const data = typeof args[0] == "object" ? args.shift() : {};
+    let msg = util.format(...args);
+    const pid = process.pid != 1 ? process.pid : null;
+    for (const key in this.parsers) {
+      if (key in data) {
+        Object.assign(data, this.parsers[key](data));
+      }
+    }
+    msg = msg || data.msg;
+    return { level, ...data, msg, pid, time: new Date() };
+  }
+  format(entry) {
+    entry.time.setMinutes(entry.time.getMinutes() - entry.time.getTimezoneOffset());
+    const data = compact(entry);
+    const formatted = typeof entry.msg == "string" ? entry.msg : util.inspect(data, { colors: true, depth: null });
+    const uword = entry.type ? colors.gray(`[${entry.type}]`) : void 0;
+    if (!entry.level) {
+      return [uword, formatted].filter(Boolean).join(" ");
+    }
+    const color = levelsMap[entry.level].c;
+    const label = colors.bold(color(`${entry.level}`));
+    const msg = [`\u{1F43C}`, label, uword, formatted].filter(Boolean).join(" ");
+    return msg;
+  }
+  parseErr({ err }) {
+    if (!(err instanceof Error))
+      err = new Error(err);
+    const stack = err.stack.split(/[\r\n]+\s*/g);
+    return {
+      err: null,
+      code: err.code,
+      class: err.constructor.name,
+      stack: stack.slice(1, -1),
+      type: err.constructor.name,
+      msg: colors.red(err.message)
+    };
+  }
+  isValid(level, type) {
+    const badLevel = levelsMap[this.level].w > levelsMap[level].w;
+    const badType = matches(this.except, type) || this.only.length > 0 && !matches(this.only, type);
+    return !(badType || badLevel);
+  }
+  stdout(level, ...args) {
+    const baseEntry = this.getEntry(level, args);
+    const entry = { ...this.defaults, ...baseEntry };
+    const valid = this.isValid(level, entry.type);
+    if (!valid)
+      return false;
+    const msg = this.format(entry);
+    console.log(msg);
+    return entry;
+  }
+  warn(...args) {
+    return this.stdout("warn", ...args);
+  }
+  info(...args) {
+    return this.stdout("info", ...args);
+  }
+  debug(...args) {
+    return this.stdout("debug", ...args);
+  }
+  error(...args) {
+    return this.stdout("error", ...args);
+  }
+  log(...args) {
+    const entry = this.getEntry(null, args);
+    if (this.level === "silent")
+      return;
+    console.log(this.format(entry));
+  }
+  get time() {
+    const base = (level, msg, ...args) => {
+      const str = `${msg} ${args.join(" ")}`;
+      const start = process.hrtime();
+      return () => {
+        const end = process.hrtime(start);
+        const ms = end[0] * 1e3 + end[1] * 1e-6;
+        this.stdout(level, { type: "hrtime", msg: `${str} ${colors.gray(`(${ms.toFixed(2)}ms)`)}` });
+      };
+    };
+    return {
+      info: (msg, ...args) => base("info", msg, ...args),
+      debug: (msg, ...args) => base("debug", msg, ...args)
+    };
+  }
+};
+var logger = new Logger();
+function quote(...str) {
+  return colors.cyan(`\`${str.join("")}\``);
+}
+export {
+  colors,
+  logger,
+  quote
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@pandacss/logger",
+  "version": "0.0.0-dev-20221121152823",
+  "description": "The core css panda library",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "author": "Segun Adebayo <joseshegs@gmail.com>",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "kleur": "^4.1.5"
+  },
+  "devDependencies": {
+    "matcher": "5.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"
+  }
+}