@holz/core 0.0.0 → 0.2.0

package/dist/holz-core.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var s=(e=>(e.Error="error",e.Warn="warn",e.Info="info",e.Debug="debug",e))(s||{});class t{constructor(r,o){this.processor=r,this.origin=o,Object.defineProperty(this,"processor",{configurable:!1,enumerable:!1})}static create(r){return new t(r,[])}namespace(r){return new t(this.processor,this.origin.concat(r))}debug(r,o){this.forwardLog(s.Debug,r,o)}info(r,o){this.forwardLog(s.Info,r,o)}warn(r,o){this.forwardLog(s.Warn,r,o)}error(r,o){this.forwardLog(s.Error,r,o)}forwardLog(r,o,i={}){this.processor.processLog({message:o,level:r,origin:this.origin,context:i})}}const c=t.create;class n{constructor(r){this.processors=r}processLog(r){this.processors.forEach(o=>{o.processLog(r)})}}function a(e){return new n(e)}class g{constructor(r,o){this.predicate=r,this.processor=o}processLog(r){this.predicate(r)&&this.processor.processLog(r)}}function f(e,r){return new g(e,r)}exports.LogLevel=s;exports.combine=a;exports.createLogger=c;exports.filter=f;

package/dist/holz-core.js

@@ -1,30 +1,39 @@
-var t = /* @__PURE__ */ ((s) => (s.Error = "error", s.Warn = "warn", s.Info = "info", s.Debug = "debug", s))(t || {});
-class e {
+var e = /* @__PURE__ */ ((s) => (s.Error = "error", s.Warn = "warn", s.Info = "info", s.Debug = "debug", s))(e || {});
+class t {
   constructor(r, o) {
-    this.processor = r, this.origin = o;
+    this.processor = r, this.origin = o, Object.defineProperty(this, "processor", {
+      configurable: !1,
+      enumerable: !1
+    });
   }
+  /**
+   * Create a new logger. The processor is up to you. There are plugins for
+   * filtering, formatting, combining multiple processors together, and more.
+   *
+   * If you wish to use more than one processor, `combine(...)` them first.
+   */
   static create(r) {
-    return new e(r, []);
+    return new t(r, []);
   }
   /** Extend the logger to attach a class or module name to logs. */
   namespace(r) {
-    return new e(this.processor, this.origin.concat(r));
+    return new t(this.processor, this.origin.concat(r));
   }
   /** Log a frequent and verbose progress update. */
   debug(r, o) {
-    this.forwardLog(t.Debug, r, o);
+    this.forwardLog(e.Debug, r, o);
   }
   /** Log a high-level progress update. */
   info(r, o) {
-    this.forwardLog(t.Info, r, o);
+    this.forwardLog(e.Info, r, o);
   }
   /** Log something concerning. */
   warn(r, o) {
-    this.forwardLog(t.Warn, r, o);
+    this.forwardLog(e.Warn, r, o);
   }
   /** Log a critical failure. */
   error(r, o) {
-    this.forwardLog(t.Error, r, o);
+    this.forwardLog(e.Error, r, o);
   }
   forwardLog(r, o, c = {}) {
     this.processor.processLog({
@@ -35,7 +44,7 @@ class e {
     });
   }
 }
-const a = e.create;
+const a = t.create;
 class i {
   constructor(r) {
     this.processors = r;
@@ -46,7 +55,7 @@ class i {
     });
   }
 }
-function h(s) {
+function f(s) {
   return new i(s);
 }
 class n {
@@ -57,13 +66,12 @@ class n {
     this.predicate(r) && this.processor.processLog(r);
   }
 }
-function g(s, r) {
+function h(s, r) {
   return new n(s, r);
 }
 export {
-  t as LogLevel,
-  h as combine,
+  e as LogLevel,
+  f as combine,
   a as createLogger,
-  g as filter
+  h as filter
 };
-//# sourceMappingURL=holz-core.js.map

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@holz/core",
-  "version": "0.0.0",
+  "version": "0.2.0",
   "description": "A structured and composable logger",
   "type": "module",
-  "main": "./dist/holz-core.umd.cjs",
+  "main": "./dist/holz-core.cjs",
   "module": "./dist/holz-core.js",
   "types": "./src/index.ts",
   "repository": {
@@ -13,7 +13,7 @@
   },
   "exports": {
     ".": {
-      "require": "./dist/holz-core.umd.cjs",
+      "require": "./dist/holz-core.cjs",
       "import": "./dist/holz-core.js"
     }
   },
@@ -33,12 +33,13 @@
     "logger"
   ],
   "scripts": {
-    "prepare": "vite build --sourcemap",
+    "prepack": "vite build",
     "test:unit": "vitest --color --passWithNoTests",
-    "test:coverage": "run test:unit --coverage"
+    "test:types": "tsc"
   },
   "devDependencies": {
     "@vitest/coverage-c8": "0.28.5",
+    "typescript": "4.9.5",
     "vite": "^4.0.0",
     "vitest": "^0.28.5"
   }

package/src/logger.ts

@@ -2,15 +2,25 @@ import type { LogProcessor, LogContext } from './types';
 import { LogLevel } from './types';
 
 class Logger {
-  static create(backend: LogProcessor): Logger {
-    return new Logger(backend, []);
+  /**
+   * Create a new logger. The processor is up to you. There are plugins for
+   * filtering, formatting, combining multiple processors together, and more.
+   *
+   * If you wish to use more than one processor, `combine(...)` them first.
+   */
+  static create(processor: LogProcessor): Logger {
+    return new Logger(processor, []);
   }
 
   private constructor(
     private processor: LogProcessor,
-    private origin: ReadonlyArray<string>
+    readonly origin: ReadonlyArray<string>
   ) {
-    // empty
+    // Non-enumerable to keep the repls clean.
+    Object.defineProperty(this, 'processor', {
+      configurable: false,
+      enumerable: false,
+    });
   }
 
   /** Extend the logger to attach a class or module name to logs. */

package/CHANGELOG.md

@@ -1,7 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## Unreleased

package/dist/holz-core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"holz-core.js","sources":["../src/types.ts","../src/logger.ts","../src/operators/combine.ts","../src/operators/filter.ts"],"sourcesContent":["/**\n * A logger is made up of log processors. These processors take structured\n * logs and do something with them. Examples are logging backends (console,\n * file, uploads) and operators (filtering, transforming, aggregating).\n */\nexport interface LogProcessor {\n  /** Do something with a log message. */\n  processLog(log: Log): void;\n}\n\n/** A log message where variables are carried as structured data. */\nexport interface Log {\n  /** The verbatim log message. Should not contain interpolated data. */\n  readonly message: string;\n\n  /** Log severity. */\n  readonly level: LogLevel;\n\n  /**\n   * Where the log message originated. Usually starts with a library or app name,\n   * followed by something more specific.\n   *\n   * @example ['logger-library', 'ConsoleBackend']\n   */\n  readonly origin: ReadonlyArray<string>;\n\n  /**\n   * Key-value pairs that provide additional context for the log message. If\n   * you're tempted to interpolate data into the message, consider using log\n   * context instead.\n   *\n   * These values must be JSON serializable.\n   *\n   * Because it's easy to accidentally include unsuitable log context (e.g.\n   * redux state, PII) nested objects are not allowed. The restriction doesn't\n   * make it impossible, but it makes it harder to miss during code review.\n   *\n   * @example { userId: 123, reason: 'disconnect' }\n   */\n  readonly context: LogContext;\n}\n\nexport enum LogLevel {\n  /** Something critical failed and we can't continue. */\n  Error = 'error',\n\n  /** Something is concerning, but we can keep going. */\n  Warn = 'warn',\n\n  /** High-level progress updates. */\n  Info = 'info',\n\n  /** Extremely verbose progress updates (usually hidden). */\n  Debug = 'debug',\n}\n\nexport type LogContext = Record<\n  string,\n  JsonPrimitive | ReadonlyArray<JsonPrimitive>\n>;\n\ntype JsonPrimitive = string | number | boolean | null | undefined;\n","import type { LogProcessor, LogContext } from './types';\nimport { LogLevel } from './types';\n\nclass Logger {\n  static create(backend: LogProcessor): Logger {\n    return new Logger(backend, []);\n  }\n\n  private constructor(\n    private processor: LogProcessor,\n    private origin: ReadonlyArray<string>\n  ) {\n    // empty\n  }\n\n  /** Extend the logger to attach a class or module name to logs. */\n  namespace(owner: string): Logger {\n    return new Logger(this.processor, this.origin.concat(owner));\n  }\n\n  /** Log a frequent and verbose progress update. */\n  debug(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Debug, message, context);\n  }\n\n  /** Log a high-level progress update. */\n  info(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Info, message, context);\n  }\n\n  /** Log something concerning. */\n  warn(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Warn, message, context);\n  }\n\n  /** Log a critical failure. */\n  error(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Error, message, context);\n  }\n\n  private forwardLog(\n    level: LogLevel,\n    message: string,\n    context: LogContext = {}\n  ) {\n    this.processor.processLog({\n      message,\n      level,\n      origin: this.origin,\n      context,\n    });\n  }\n}\n\nexport const createLogger = Logger.create;\n","import type { Log, LogProcessor } from '../types';\n\nclass CombinedLogProcessor implements LogProcessor {\n  constructor(private processors: Array<LogProcessor>) {\n    // empty\n  }\n\n  processLog(log: Log) {\n    this.processors.forEach((processor) => {\n      processor.processLog(log);\n    });\n  }\n}\n\n/**\n * Combine several log processors into a single log processor. Each one is\n * called in sequence. Useful for sending a single log to multiple log\n * destinations.\n */\nexport default function combine(processors: Array<LogProcessor>): LogProcessor {\n  return new CombinedLogProcessor(processors);\n}\n","import type { Log, LogProcessor } from '../types';\n\nclass LogFilter implements LogProcessor {\n  constructor(\n    private predicate: (log: Log) => boolean,\n    private processor: LogProcessor\n  ) {}\n\n  processLog(log: Log) {\n    if (this.predicate(log)) {\n      this.processor.processLog(log);\n    }\n  }\n}\n\n/**\n * Filter logs based on a filter function. If the function returns true, the\n * log is kept and forwarded onto the next processor, otherwise it is\n * discarded.\n */\nexport default function filter(\n  /** Returns `true` to forward the log. */\n  predicate: (log: Log) => boolean,\n  /** Where to send the log if it passes the filter. */\n  processor: LogProcessor\n): LogProcessor {\n  return new LogFilter(predicate, processor);\n}\n"],"names":["LogLevel","Logger","processor","origin","backend","owner","message","context","level","createLogger","CombinedLogProcessor","processors","log","combine","LogFilter","predicate","filter"],"mappings":"AA0CY,IAAAA,sBAAAA,OAEVA,EAAA,QAAQ,SAGRA,EAAA,OAAO,QAGPA,EAAA,OAAO,QAGPA,EAAA,QAAQ,SAXEA,IAAAA,KAAA,CAAA,CAAA;ACvCZ,MAAMC,EAAO;AAAA,EAKH,YACEC,GACAC,GACR;AAFQ,SAAA,YAAAD,GACA,KAAA,SAAAC;AAAA,EAGV;AAAA,EATA,OAAO,OAAOC,GAA+B;AAC3C,WAAO,IAAIH,EAAOG,GAAS,CAAA,CAAE;AAAA,EAC/B;AAAA;AAAA,EAUA,UAAUC,GAAuB;AACxB,WAAA,IAAIJ,EAAO,KAAK,WAAW,KAAK,OAAO,OAAOI,CAAK,CAAC;AAAA,EAC7D;AAAA;AAAA,EAGA,MAAMC,GAAiBC,GAAsB;AAC3C,SAAK,WAAWP,EAAS,OAAOM,GAASC,CAAO;AAAA,EAClD;AAAA;AAAA,EAGA,KAAKD,GAAiBC,GAAsB;AAC1C,SAAK,WAAWP,EAAS,MAAMM,GAASC,CAAO;AAAA,EACjD;AAAA;AAAA,EAGA,KAAKD,GAAiBC,GAAsB;AAC1C,SAAK,WAAWP,EAAS,MAAMM,GAASC,CAAO;AAAA,EACjD;AAAA;AAAA,EAGA,MAAMD,GAAiBC,GAAsB;AAC3C,SAAK,WAAWP,EAAS,OAAOM,GAASC,CAAO;AAAA,EAClD;AAAA,EAEQ,WACNC,GACAF,GACAC,IAAsB,CAAA,GACtB;AACA,SAAK,UAAU,WAAW;AAAA,MACxB,SAAAD;AAAA,MACA,OAAAE;AAAA,MACA,QAAQ,KAAK;AAAA,MACb,SAAAD;AAAA,IAAA,CACD;AAAA,EACH;AACF;AAEO,MAAME,IAAeR,EAAO;ACpDnC,MAAMS,EAA6C;AAAA,EACjD,YAAoBC,GAAiC;AAAjC,SAAA,aAAAA;AAAA,EAEpB;AAAA,EAEA,WAAWC,GAAU;AACd,SAAA,WAAW,QAAQ,CAACV,MAAc;AACrC,MAAAA,EAAU,WAAWU,CAAG;AAAA,IAAA,CACzB;AAAA,EACH;AACF;AAOA,SAAwBC,EAAQF,GAA+C;AACtE,SAAA,IAAID,EAAqBC,CAAU;AAC5C;ACnBA,MAAMG,EAAkC;AAAA,EACtC,YACUC,GACAb,GACR;AAFQ,SAAA,YAAAa,GACA,KAAA,YAAAb;AAAA,EACP;AAAA,EAEH,WAAWU,GAAU;AACf,IAAA,KAAK,UAAUA,CAAG,KACf,KAAA,UAAU,WAAWA,CAAG;AAAA,EAEjC;AACF;AAOwB,SAAAI,EAEtBD,GAEAb,GACc;AACP,SAAA,IAAIY,EAAUC,GAAWb,CAAS;AAC3C;"}

package/dist/holz-core.umd.cjs

@@ -1,2 +0,0 @@
-(function(t,s){typeof exports=="object"&&typeof module<"u"?s(exports):typeof define=="function"&&define.amd?define(["exports"],s):(t=typeof globalThis<"u"?globalThis:t||self,s(t["holz-core"]={}))})(this,function(t){"use strict";var s=(e=>(e.Error="error",e.Warn="warn",e.Info="info",e.Debug="debug",e))(s||{});class i{constructor(r,o){this.processor=r,this.origin=o}static create(r){return new i(r,[])}namespace(r){return new i(this.processor,this.origin.concat(r))}debug(r,o){this.forwardLog(s.Debug,r,o)}info(r,o){this.forwardLog(s.Info,r,o)}warn(r,o){this.forwardLog(s.Warn,r,o)}error(r,o){this.forwardLog(s.Error,r,o)}forwardLog(r,o,d={}){this.processor.processLog({message:o,level:r,origin:this.origin,context:d})}}const n=i.create;class c{constructor(r){this.processors=r}processLog(r){this.processors.forEach(o=>{o.processLog(r)})}}function f(e){return new c(e)}class a{constructor(r,o){this.predicate=r,this.processor=o}processLog(r){this.predicate(r)&&this.processor.processLog(r)}}function u(e,r){return new a(e,r)}t.LogLevel=s,t.combine=f,t.createLogger=n,t.filter=u,Object.defineProperty(t,Symbol.toStringTag,{value:"Module"})});
-//# sourceMappingURL=holz-core.umd.cjs.map

package/dist/holz-core.umd.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"holz-core.umd.cjs","sources":["../src/types.ts","../src/logger.ts","../src/operators/combine.ts","../src/operators/filter.ts"],"sourcesContent":["/**\n * A logger is made up of log processors. These processors take structured\n * logs and do something with them. Examples are logging backends (console,\n * file, uploads) and operators (filtering, transforming, aggregating).\n */\nexport interface LogProcessor {\n  /** Do something with a log message. */\n  processLog(log: Log): void;\n}\n\n/** A log message where variables are carried as structured data. */\nexport interface Log {\n  /** The verbatim log message. Should not contain interpolated data. */\n  readonly message: string;\n\n  /** Log severity. */\n  readonly level: LogLevel;\n\n  /**\n   * Where the log message originated. Usually starts with a library or app name,\n   * followed by something more specific.\n   *\n   * @example ['logger-library', 'ConsoleBackend']\n   */\n  readonly origin: ReadonlyArray<string>;\n\n  /**\n   * Key-value pairs that provide additional context for the log message. If\n   * you're tempted to interpolate data into the message, consider using log\n   * context instead.\n   *\n   * These values must be JSON serializable.\n   *\n   * Because it's easy to accidentally include unsuitable log context (e.g.\n   * redux state, PII) nested objects are not allowed. The restriction doesn't\n   * make it impossible, but it makes it harder to miss during code review.\n   *\n   * @example { userId: 123, reason: 'disconnect' }\n   */\n  readonly context: LogContext;\n}\n\nexport enum LogLevel {\n  /** Something critical failed and we can't continue. */\n  Error = 'error',\n\n  /** Something is concerning, but we can keep going. */\n  Warn = 'warn',\n\n  /** High-level progress updates. */\n  Info = 'info',\n\n  /** Extremely verbose progress updates (usually hidden). */\n  Debug = 'debug',\n}\n\nexport type LogContext = Record<\n  string,\n  JsonPrimitive | ReadonlyArray<JsonPrimitive>\n>;\n\ntype JsonPrimitive = string | number | boolean | null | undefined;\n","import type { LogProcessor, LogContext } from './types';\nimport { LogLevel } from './types';\n\nclass Logger {\n  static create(backend: LogProcessor): Logger {\n    return new Logger(backend, []);\n  }\n\n  private constructor(\n    private processor: LogProcessor,\n    private origin: ReadonlyArray<string>\n  ) {\n    // empty\n  }\n\n  /** Extend the logger to attach a class or module name to logs. */\n  namespace(owner: string): Logger {\n    return new Logger(this.processor, this.origin.concat(owner));\n  }\n\n  /** Log a frequent and verbose progress update. */\n  debug(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Debug, message, context);\n  }\n\n  /** Log a high-level progress update. */\n  info(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Info, message, context);\n  }\n\n  /** Log something concerning. */\n  warn(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Warn, message, context);\n  }\n\n  /** Log a critical failure. */\n  error(message: string, context?: LogContext) {\n    this.forwardLog(LogLevel.Error, message, context);\n  }\n\n  private forwardLog(\n    level: LogLevel,\n    message: string,\n    context: LogContext = {}\n  ) {\n    this.processor.processLog({\n      message,\n      level,\n      origin: this.origin,\n      context,\n    });\n  }\n}\n\nexport const createLogger = Logger.create;\n","import type { Log, LogProcessor } from '../types';\n\nclass CombinedLogProcessor implements LogProcessor {\n  constructor(private processors: Array<LogProcessor>) {\n    // empty\n  }\n\n  processLog(log: Log) {\n    this.processors.forEach((processor) => {\n      processor.processLog(log);\n    });\n  }\n}\n\n/**\n * Combine several log processors into a single log processor. Each one is\n * called in sequence. Useful for sending a single log to multiple log\n * destinations.\n */\nexport default function combine(processors: Array<LogProcessor>): LogProcessor {\n  return new CombinedLogProcessor(processors);\n}\n","import type { Log, LogProcessor } from '../types';\n\nclass LogFilter implements LogProcessor {\n  constructor(\n    private predicate: (log: Log) => boolean,\n    private processor: LogProcessor\n  ) {}\n\n  processLog(log: Log) {\n    if (this.predicate(log)) {\n      this.processor.processLog(log);\n    }\n  }\n}\n\n/**\n * Filter logs based on a filter function. If the function returns true, the\n * log is kept and forwarded onto the next processor, otherwise it is\n * discarded.\n */\nexport default function filter(\n  /** Returns `true` to forward the log. */\n  predicate: (log: Log) => boolean,\n  /** Where to send the log if it passes the filter. */\n  processor: LogProcessor\n): LogProcessor {\n  return new LogFilter(predicate, processor);\n}\n"],"names":["LogLevel","Logger","processor","origin","backend","owner","message","context","level","createLogger","CombinedLogProcessor","processors","log","combine","LogFilter","predicate","filter"],"mappings":"oOA0CY,IAAAA,GAAAA,IAEVA,EAAA,MAAQ,QAGRA,EAAA,KAAO,OAGPA,EAAA,KAAO,OAGPA,EAAA,MAAQ,QAXEA,IAAAA,GAAA,CAAA,CAAA,ECvCZ,MAAMC,CAAO,CAKH,YACEC,EACAC,EACR,CAFQ,KAAA,UAAAD,EACA,KAAA,OAAAC,CAGV,CATA,OAAO,OAAOC,EAA+B,CAC3C,OAAO,IAAIH,EAAOG,EAAS,CAAA,CAAE,CAC/B,CAUA,UAAUC,EAAuB,CACxB,OAAA,IAAIJ,EAAO,KAAK,UAAW,KAAK,OAAO,OAAOI,CAAK,CAAC,CAC7D,CAGA,MAAMC,EAAiBC,EAAsB,CAC3C,KAAK,WAAWP,EAAS,MAAOM,EAASC,CAAO,CAClD,CAGA,KAAKD,EAAiBC,EAAsB,CAC1C,KAAK,WAAWP,EAAS,KAAMM,EAASC,CAAO,CACjD,CAGA,KAAKD,EAAiBC,EAAsB,CAC1C,KAAK,WAAWP,EAAS,KAAMM,EAASC,CAAO,CACjD,CAGA,MAAMD,EAAiBC,EAAsB,CAC3C,KAAK,WAAWP,EAAS,MAAOM,EAASC,CAAO,CAClD,CAEQ,WACNC,EACAF,EACAC,EAAsB,CAAA,EACtB,CACA,KAAK,UAAU,WAAW,CACxB,QAAAD,EACA,MAAAE,EACA,OAAQ,KAAK,OACb,QAAAD,CAAA,CACD,CACH,CACF,CAEa,MAAAE,EAAeR,EAAO,OCpDnC,MAAMS,CAA6C,CACjD,YAAoBC,EAAiC,CAAjC,KAAA,WAAAA,CAEpB,CAEA,WAAWC,EAAU,CACd,KAAA,WAAW,QAASV,GAAc,CACrCA,EAAU,WAAWU,CAAG,CAAA,CACzB,CACH,CACF,CAOA,SAAwBC,EAAQF,EAA+C,CACtE,OAAA,IAAID,EAAqBC,CAAU,CAC5C,CCnBA,MAAMG,CAAkC,CACtC,YACUC,EACAb,EACR,CAFQ,KAAA,UAAAa,EACA,KAAA,UAAAb,CACP,CAEH,WAAWU,EAAU,CACf,KAAK,UAAUA,CAAG,GACf,KAAA,UAAU,WAAWA,CAAG,CAEjC,CACF,CAOwB,SAAAI,EAEtBD,EAEAb,EACc,CACP,OAAA,IAAIY,EAAUC,EAAWb,CAAS,CAC3C"}