zeed 0.8.3 → 0.8.4

package/dist/index.log.cjs

@@ -1,26 +1,662 @@
-"use strict";'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, '__esModule', { value: true });
+// src/index.log.ts
+var index_log_exports = {};
+__export(index_log_exports, {
+  Logger: () => Logger,
+  LoggerBrowserHandler: () => LoggerBrowserHandler,
+  LoggerBrowserSetupDebugFactory: () => LoggerBrowserSetupDebugFactory,
+  activateConsoleDebug: () => activateConsoleDebug
+});
+module.exports = __toCommonJS(index_log_exports);
 
-var chunkKG3OKVAH_cjs = require('./chunk-KG3OKVAH.cjs');
-var chunkC66X5FP6_cjs = require('./chunk-C66X5FP6.cjs');
+// src/common/data/is.ts
+function isPrimitive(obj) {
+  return Object(obj) !== obj;
+}
+__name(isPrimitive, "isPrimitive");
 
+// src/common/data/deep.ts
+function deepEqual(a, b, hash = /* @__PURE__ */ new WeakSet()) {
+  if (a === b) {
+    return true;
+  }
+  if (hash.has(b)) {
+    return true;
+  }
+  if (!isPrimitive(b)) {
+    hash.add(b);
+  }
+  if (!(a instanceof Object) || !(b instanceof Object)) {
+    return false;
+  }
+  if (a.constructor !== b.constructor) {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let p in a) {
+    if (!a.hasOwnProperty(p)) {
+      continue;
+    }
+    if (!b.hasOwnProperty(p)) {
+      return false;
+    }
+    let aa = a[p];
+    let bb = b[p];
+    if (!deepEqual(aa, bb, hash)) {
+      return false;
+    }
+  }
+  for (let p in b) {
+    if (b.hasOwnProperty(p) && !a.hasOwnProperty(p)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(deepEqual, "deepEqual");
 
+// src/common/log-filter.ts
+function getNamespaceFilterString(defaultNamespaceFilter2) {
+  if (defaultNamespaceFilter2 === true || defaultNamespaceFilter2 === "true" || defaultNamespaceFilter2 === "1" || typeof defaultNamespaceFilter2 === "number" && defaultNamespaceFilter2 !== 0) {
+    defaultNamespaceFilter2 = "*";
+  } else if (defaultNamespaceFilter2 === false || defaultNamespaceFilter2 === "false" || defaultNamespaceFilter2 === 0 || defaultNamespaceFilter2 === "0" || defaultNamespaceFilter2 == null || defaultNamespaceFilter2 === "null" || defaultNamespaceFilter2 === "undefined") {
+    defaultNamespaceFilter2 = "";
+  } else {
+    defaultNamespaceFilter2 = String(defaultNamespaceFilter2);
+  }
+  return defaultNamespaceFilter2;
+}
+__name(getNamespaceFilterString, "getNamespaceFilterString");
+var defaultNamespaceFilter = getNamespaceFilterString(
+  typeof process !== "undefined" ? process.env.ZEED ?? process.env.DEBUG : typeof localStorage !== "undefined" ? localStorage.zeed ?? localStorage.debug : "*"
+);
+function useNamespaceFilter(filter = defaultNamespaceFilter) {
+  let fn;
+  let reject = [];
+  let accept = [];
+  if (!filter) {
+    fn = /* @__PURE__ */ __name(function(name) {
+      return false;
+    }, "fn");
+  } else if (filter === "*") {
+    fn = /* @__PURE__ */ __name(function(name) {
+      return true;
+    }, "fn");
+  } else {
+    let i;
+    const split = filter.split(/[\s,]+/);
+    const len = split.length;
+    for (i = 0; i < len; i++) {
+      if (!split[i]) {
+        continue;
+      }
+      let template = split[i].replace(/\*/g, ".*?");
+      if (template[0] === "-") {
+        reject.push(new RegExp("^" + template.substr(1) + "$"));
+      } else {
+        accept.push(new RegExp("^" + template + "$"));
+      }
+    }
+    fn = /* @__PURE__ */ __name(function(name) {
+      if (reject.length === 0 && accept.length === 0) {
+        return true;
+      }
+      let i2, len2;
+      for (i2 = 0, len2 = reject.length; i2 < len2; i2++) {
+        if (reject[i2].test(name)) {
+          return false;
+        }
+      }
+      for (i2 = 0, len2 = accept.length; i2 < len2; i2++) {
+        if (accept[i2].test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }, "fn");
+  }
+  fn.accept = accept;
+  fn.reject = reject;
+  fn.filter = filter;
+  return fn;
+}
+__name(useNamespaceFilter, "useNamespaceFilter");
+var defaultLevelFilter = typeof process !== "undefined" ? process.env.ZEED_LEVEL ?? process.env.LEVEL ?? process.env.DEBUG_LEVEL : typeof localStorage !== "undefined" ? localStorage.zeed_level ?? localStorage.level ?? localStorage.debug_level : void 0;
+function parseLogLevel(filter) {
+  if (filter === false)
+    return Infinity /* off */;
+  if (typeof filter === "number")
+    return filter;
+  if (typeof filter === "string") {
+    const l = LogLevelAlias[filter.toLocaleLowerCase().trim()];
+    if (l != null)
+      return l;
+  }
+  return -1 /* all */;
+}
+__name(parseLogLevel, "parseLogLevel");
+function useLevelFilter(filter = defaultLevelFilter) {
+  const filterLevel = parseLogLevel(filter);
+  return (level) => level >= filterLevel;
+}
+__name(useLevelFilter, "useLevelFilter");
 
-Object.defineProperty(exports, 'LoggerBrowserHandler', {
-  enumerable: true,
-  get: function () { return chunkKG3OKVAH_cjs.LoggerBrowserHandler; }
-});
-Object.defineProperty(exports, 'LoggerBrowserSetupDebugFactory', {
-  enumerable: true,
-  get: function () { return chunkKG3OKVAH_cjs.LoggerBrowserSetupDebugFactory; }
-});
-Object.defineProperty(exports, 'activateConsoleDebug', {
-  enumerable: true,
-  get: function () { return chunkKG3OKVAH_cjs.activateConsoleDebug; }
-});
-Object.defineProperty(exports, 'Logger', {
-  enumerable: true,
-  get: function () { return chunkC66X5FP6_cjs.Logger; }
+// src/common/log-base.ts
+var LogLevelAlias = {
+  "*": -1 /* all */,
+  a: -1 /* all */,
+  all: -1 /* all */,
+  d: 0 /* debug */,
+  dbg: 0 /* debug */,
+  debug: 0 /* debug */,
+  i: 1 /* info */,
+  inf: 1 /* info */,
+  info: 1 /* info */,
+  w: 2 /* warn */,
+  warn: 2 /* warn */,
+  warning: 2 /* warn */,
+  e: 3 /* error */,
+  err: 3 /* error */,
+  error: 3 /* error */,
+  fatal: 4 /* fatal */,
+  off: Infinity /* off */,
+  "-": Infinity /* off */
+};
+function LoggerContext(prefix = "") {
+  let logHandlers = [LoggerConsoleHandler()];
+  let logAssertLevel = 2 /* warn */;
+  let logCheckNamespace = /* @__PURE__ */ __name((name) => true, "logCheckNamespace");
+  let logLock = false;
+  let logFactory = LoggerBaseFactory;
+  function LoggerBaseFactory(name = "", level) {
+    function log(...messages) {
+      emit({
+        name,
+        messages,
+        level: 0 /* debug */
+      });
+    }
+    __name(log, "log");
+    log.label = name;
+    log.active = true;
+    log.level = parseLogLevel(level ?? -1 /* all */);
+    log.extend = function(prefix2) {
+      return logFactory(name ? `${name}:${prefix2}` : prefix2);
+    };
+    const emit = /* @__PURE__ */ __name((msg) => {
+      if (log.active === true) {
+        if (msg.level >= Logger2.level && msg.level >= log.level) {
+          if (logCheckNamespace(name)) {
+            for (let handler of logHandlers) {
+              if (handler)
+                handler(msg);
+            }
+          }
+        }
+      }
+    }, "emit");
+    log.debug = function(...messages) {
+      emit({
+        name,
+        messages,
+        level: 0 /* debug */
+      });
+    };
+    log.info = function(...messages) {
+      emit({
+        name,
+        messages,
+        level: 1 /* info */
+      });
+    };
+    log.warn = function(...messages) {
+      emit({
+        name,
+        messages,
+        level: 2 /* warn */
+      });
+    };
+    log.error = function(...messages) {
+      emit({
+        name,
+        messages,
+        level: 3 /* error */
+      });
+    };
+    log.assert = function(cond, ...messages) {
+      if (!cond) {
+        if (typeof console !== void 0) {
+          if (console.assert) {
+            console.assert(cond, ...messages);
+          } else {
+            console.error(`Assert did fail with: ${cond}`, ...messages);
+          }
+        }
+        emit({
+          name,
+          messages: messages || [`Assert did fail with: ${cond}`],
+          level: logAssertLevel
+        });
+      }
+    };
+    log.assertEqual = function(value, expected, ...args) {
+      let equal = deepEqual(value, expected);
+      if (!equal) {
+        log.assert(
+          equal,
+          `Assert did fail. Expected ${expected} got ${value}`,
+          expected,
+          value,
+          ...args
+        );
+      }
+    };
+    log.assertNotEqual = function(value, expected, ...args) {
+      let equal = deepEqual(value, expected);
+      if (equal) {
+        log.assert(
+          equal,
+          `Assert did fail. Expected ${expected} not to be equal with ${value}`,
+          expected,
+          value,
+          ...args
+        );
+      }
+    };
+    return log;
+  }
+  __name(LoggerBaseFactory, "LoggerBaseFactory");
+  function Logger2(name = "", level) {
+    return logFactory(name, level);
+  }
+  __name(Logger2, "Logger");
+  Logger2.registerHandler = function(handler) {
+    logHandlers.push(handler);
+  };
+  Logger2.setFilter = function(namespaces2) {
+    logCheckNamespace = useNamespaceFilter(namespaces2);
+  };
+  Logger2.setLock = (lock = true) => logLock = lock;
+  Logger2.setHandlers = function(handlers = []) {
+    if (logFactory !== LoggerBaseFactory) {
+      logFactory = LoggerBaseFactory;
+    }
+    if (logLock)
+      return;
+    logHandlers = [...handlers].filter((h) => typeof h === "function");
+  };
+  Logger2.level = -1 /* all */;
+  Logger2.setLogLevel = function(level = -1 /* all */) {
+    if (logLock)
+      return;
+    Logger2.level = level;
+  };
+  Logger2.setFactory = function(factory) {
+    if (logLock)
+      return;
+    logFactory = factory;
+  };
+  return Logger2;
+}
+__name(LoggerContext, "LoggerContext");
+
+// src/common/log-console.ts
+function LoggerConsoleHandler(opt = {}) {
+  const {
+    level = void 0,
+    filter = void 0,
+    colors: colors2 = true,
+    levelHelper = false,
+    nameBrackets = true,
+    padding = 16
+  } = opt;
+  const matchesNamespace = useNamespaceFilter(filter);
+  const matchesLevel = useLevelFilter(level);
+  return (msg) => {
+    if (!matchesLevel(msg.level))
+      return;
+    if (!matchesNamespace(msg.name))
+      return;
+    let name = msg.name ? `[${msg.name}]` : "";
+    switch (msg.level) {
+      case 1 /* info */:
+        console.info(`I|*   ${name}`, ...msg.messages);
+        break;
+      case 2 /* warn */:
+        console.warn(`W|**  ${name}`, ...msg.messages);
+        break;
+      case 3 /* error */:
+        console.error(`E|*** ${name}`, ...msg.messages);
+        break;
+      default:
+        console.debug(`D|    ${name}`, ...msg.messages);
+        break;
+    }
+  };
+}
+__name(LoggerConsoleHandler, "LoggerConsoleHandler");
+
+// src/common/global.ts
+function _global() {
+  if (typeof self !== "undefined")
+    return self;
+  if (typeof window !== "undefined")
+    return window;
+  if (typeof global !== "undefined")
+    return global;
+  if (typeof globalThis !== "undefined")
+    return globalThis;
+  throw new Error("unable to locate global object");
+}
+__name(_global, "_global");
+function getGlobalContext() {
+  let gcontext = _global();
+  if (gcontext._zeedGlobal == null) {
+    gcontext._zeedGlobal = {};
+  }
+  return gcontext._zeedGlobal;
+}
+__name(getGlobalContext, "getGlobalContext");
+
+// src/common/log.ts
+var globalLogger;
+function getLoggerContext() {
+  let logger = LoggerContext();
+  logger.setHandlers([LoggerConsoleHandler()]);
+  return logger;
+}
+__name(getLoggerContext, "getLoggerContext");
+try {
+  let _global2 = getGlobalContext();
+  if (_global2 != null) {
+    if ((_global2 == null ? void 0 : _global2.logger) == null) {
+      globalLogger = getLoggerContext();
+      _global2.logger = globalLogger;
+    } else {
+      globalLogger = _global2.logger;
+    }
+  } else {
+    globalLogger = getLoggerContext();
+  }
+} catch (e) {
+  globalLogger = getLoggerContext();
+}
+var Logger = globalLogger;
+
+// src/common/time.ts
+var getTimestamp = /* @__PURE__ */ __name(() => Date.now(), "getTimestamp");
+function formatMilliseconds(ms) {
+  return ms > 999 ? (ms / 1e3).toFixed(1) + "s" : ms.toFixed(2) + "ms";
+}
+__name(formatMilliseconds, "formatMilliseconds");
+
+// src/browser/log-colors.ts
+var colors = [
+  "#0000CC",
+  "#0000FF",
+  "#0033CC",
+  "#0033FF",
+  "#0066CC",
+  "#0066FF",
+  "#0099CC",
+  "#0099FF",
+  "#00CC00",
+  "#00CC33",
+  "#00CC66",
+  "#00CC99",
+  "#00CCCC",
+  "#00CCFF",
+  "#3300CC",
+  "#3300FF",
+  "#3333CC",
+  "#3333FF",
+  "#3366CC",
+  "#3366FF",
+  "#3399CC",
+  "#3399FF",
+  "#33CC00",
+  "#33CC33",
+  "#33CC66",
+  "#33CC99",
+  "#33CCCC",
+  "#33CCFF",
+  "#6600CC",
+  "#6600FF",
+  "#6633CC",
+  "#6633FF",
+  "#66CC00",
+  "#66CC33",
+  "#9900CC",
+  "#9900FF",
+  "#9933CC",
+  "#9933FF",
+  "#99CC00",
+  "#99CC33",
+  "#CC0000",
+  "#CC0033",
+  "#CC0066",
+  "#CC0099",
+  "#CC00CC",
+  "#CC00FF",
+  "#CC3300",
+  "#CC3333",
+  "#CC3366",
+  "#CC3399",
+  "#CC33CC",
+  "#CC33FF",
+  "#CC6600",
+  "#CC6633",
+  "#CC9900",
+  "#CC9933",
+  "#CCCC00",
+  "#CCCC33",
+  "#FF0000",
+  "#FF0033",
+  "#FF0066",
+  "#FF0099",
+  "#FF00CC",
+  "#FF00FF",
+  "#FF3300",
+  "#FF3333",
+  "#FF3366",
+  "#FF3399",
+  "#FF33CC",
+  "#FF33FF",
+  "#FF6600",
+  "#FF6633",
+  "#FF9900",
+  "#FF9933",
+  "#FFCC00",
+  "#FFCC33"
+];
+function supportsColors() {
+  if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+    return true;
+  }
+  if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+    return false;
+  }
+  return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+}
+__name(supportsColors, "supportsColors");
+function selectColor(namespace) {
+  let hash = 0;
+  for (let i = 0; i < namespace.length; i++) {
+    hash = (hash << 5) - hash + namespace.charCodeAt(i);
+    hash |= 0;
+  }
+  return colors[Math.abs(hash) % colors.length];
+}
+__name(selectColor, "selectColor");
+
+// src/browser/log-browser.ts
+var styleFont = `font-family: "JetBrains Mono", Menlo; font-size: 11px;`;
+var styleDefault = `${styleFont}`;
+var styleBold = `font-weight: 600; ${styleFont}`;
+var useColors = supportsColors();
+var namespaces = {};
+var time = getTimestamp();
+function LoggerBrowserHandler(opt = {}) {
+  const {
+    filter = void 0,
+    level = void 0,
+    colors: colors2 = true,
+    levelHelper = false,
+    nameBrackets = true,
+    padding = 16
+  } = opt;
+  const matchesNamespace = useNamespaceFilter(filter);
+  const matchesLevel = useLevelFilter(level);
+  return (msg) => {
+    var _a;
+    if (!matchesLevel(msg.level))
+      return;
+    if (!matchesNamespace(msg.name))
+      return;
+    const timeNow = getTimestamp();
+    let name = msg.name || "";
+    let ninfo = namespaces[name || ""];
+    if (ninfo == null) {
+      ninfo = {
+        color: selectColor(name)
+      };
+      namespaces[name] = ninfo;
+    }
+    const diff = formatMilliseconds(timeNow - time);
+    let args;
+    if (padding > 0) {
+      name = name.padEnd(16, " ");
+    }
+    if (colors2 && useColors) {
+      args = [`%c${name}%c 	%s %c+${diff}`];
+      args.push(`color:${ninfo.color}; ${styleBold}`);
+      args.push(styleDefault);
+      args.push(((_a = msg.messages) == null ? void 0 : _a[0]) ?? "");
+      args.push(`color:${ninfo.color};`);
+      args.push(...msg.messages.slice(1));
+    } else {
+      args = [name, ...msg.messages, `+${diff}`];
+    }
+    switch (msg.level) {
+      case 1 /* info */:
+        if (opt.levelHelper)
+          args[0] = `I|*   ` + args[0];
+        console.info(...args);
+        break;
+      case 2 /* warn */:
+        if (opt.levelHelper)
+          args[0] = `W|**  ` + args[0];
+        console.warn(...args);
+        break;
+      case 3 /* error */:
+        if (opt.levelHelper)
+          args[0] = `E|*** ` + args[0];
+        console.error(...args);
+        break;
+      default:
+        if (opt.levelHelper)
+          args[0] = `D|    ` + args[0];
+        console.debug(...args);
+        break;
+    }
+  };
+}
+__name(LoggerBrowserHandler, "LoggerBrowserHandler");
+function LoggerBrowserSetupDebugFactory(opt = {}) {
+  const filter = opt.filter ?? localStorage.zeed ?? localStorage.debug;
+  return /* @__PURE__ */ __name(function LoggerBrowserDebugFactory(name = "") {
+    let log;
+    const matches = useNamespaceFilter(filter);
+    if (matches(name)) {
+      let fixedArgs = [];
+      if (useColors) {
+        const color = selectColor(name);
+        fixedArgs.push(`%c${name.padEnd(16, " ")}%c 	%s`);
+        fixedArgs.push(`color:${color}; ${styleBold}`);
+        fixedArgs.push(styleDefault);
+      } else {
+        fixedArgs.push(`[${name}] 	%s`);
+      }
+      log = console.debug.bind(console, ...fixedArgs);
+      log.debug = console.debug.bind(console, ...fixedArgs);
+      log.info = console.info.bind(console, ...fixedArgs);
+      log.warn = console.warn.bind(console, ...fixedArgs);
+      log.error = console.error.bind(console, ...fixedArgs);
+      log.assert = console.assert.bind(console);
+      log.assertEqual = function(value, expected, ...args) {
+        let equal = deepEqual(value, expected);
+        if (!equal) {
+          log.assert(
+            equal,
+            `Assert did fail. Expected ${expected} got ${value}`,
+            expected,
+            value,
+            ...args
+          );
+        }
+      };
+      log.assertNotEqual = function(value, expected, ...args) {
+        let equal = deepEqual(value, expected);
+        if (equal) {
+          log.assert(
+            equal,
+            `Assert did fail. Expected ${expected} not to be equal with ${value}`,
+            expected,
+            value,
+            ...args
+          );
+        }
+      };
+    } else {
+      const noop = /* @__PURE__ */ __name(() => {
+      }, "noop");
+      log = noop;
+      log.debug = noop;
+      log.info = noop;
+      log.warn = noop;
+      log.error = noop;
+      log.assert = noop;
+      log.assertEqual = noop;
+      log.assertNotEqual = noop;
+    }
+    log.extend = (subName) => {
+      return LoggerBrowserDebugFactory(name ? `${name}:${subName}` : subName);
+    };
+    log.label = name;
+    return log;
+  }, "LoggerBrowserDebugFactory");
+}
+__name(LoggerBrowserSetupDebugFactory, "LoggerBrowserSetupDebugFactory");
+function activateConsoleDebug(opt = {}) {
+  console.info("activateConsoleDebug is activated by default in browsers");
+}
+__name(activateConsoleDebug, "activateConsoleDebug");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  LoggerBrowserHandler,
+  LoggerBrowserSetupDebugFactory,
+  activateConsoleDebug
 });
 //# sourceMappingURL=index.log.cjs.map