@holz/pattern-filter 0.2.0 → 0.6.0

package/README.md

@@ -0,0 +1,32 @@
+# `@holz/pattern-filter`
+
+`@holz/pattern-filter` is a library that allows you to conditionally filter out logs based on a set of patterns. It can be used in combination with other plugins like [`@holz/console-backend`](https://github.com/PsychoLlama/holz/tree/main/packages/holz-console-backend) or [`@holz/ansi-terminal-backend`](https://github.com/PsychoLlama/holz/tree/main/packages/holz-ansi-terminal-backend) to process and display filtered logs.
+
+## Usage
+
+To use `@holz/pattern-filter`, you first need to import it and create a filter with `createPatternFilter()`:
+
+```typescript
+import { createPatternFilter } from '@holz/pattern-filter';
+
+const filter = createPatternFilter({
+  pattern: 'my-app*, library*, -library:chatty*',
+  processor: plugin,
+});
+```
+
+The `pattern` option is a comma-separated list of patterns that determine which logs to show and which to hide. In the example above, logs with origins that start with `'my-app'` or `'library'` will be shown, but logs with the origin `'library:chatty'` will be hidden.
+
+The `processor` option is where you specify which plugin should process the filtered logs. This can be any Holz plugin.
+
+## Patterns
+
+Patterns are strings that match against `log.origin`, which is a property of each log object. Origins are added when you call `logger.namepspace(...)`. The following syntax is supported:
+
+- `*` matches zero or more characters.
+- `-` at the beginning of a pattern negates it, so that logs with origins matching the pattern are hidden rather than shown.
+
+For example:
+
+- `my-app*` matches origins that start with `'my-app'`, such as `'my-app:home'` or `'my-app:login'`.
+- `library*, -library:chatty*` matches origins that start with `'library'`, except for origins that start with `'library:chatty'`.

package/dist/holz-pattern-filter.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const l=t=>t.split(/[\s,]+/).filter(Boolean).reduce((s,r)=>(r[0]==="-"?s.exclude.push(c(r.slice(1))):s.include.push(c(r)),s),{include:[],exclude:[]}),n=(t,e)=>t.exclude.every(s=>!s.test(e))&&t.include.some(s=>s.test(e)),c=t=>{const e=t.replace(/\*/g,".*?");return new RegExp(`^${e}$`)};class o{constructor(e){this.pattern=e.pattern,this.processor=e.processor,this.filters=l(e.pattern)}processLog(e){n(this.filters,e.origin.join(":"))&&this.processor.processLog(e)}}exports.PatternFilter=o;exports.default=o;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=t=>t.split(/[\s,]+/).filter(Boolean).reduce((e,n)=>(n[0]==="-"?e.exclude.push(c(n.slice(1))):e.include.push(c(n)),e),{include:[],exclude:[]}),i=(t,r)=>t.exclude.every(e=>!e.test(r))&&t.include.some(e=>e.test(r)),c=t=>{const r=t.replace(/\*/g,".*?");return new RegExp(`^${r}$`)};function l({processor:t,pattern:r}){const e=s(r);return n=>{i(e,n.origin.join(":"))&&t(n)}}exports.createPatternFilter=l;

package/dist/holz-pattern-filter.js

@@ -1,19 +1,19 @@
-const o = (s) => s.split(/[\s,]+/).filter(Boolean).reduce(
-  (t, r) => (r[0] === "-" ? t.exclude.push(c(r.slice(1))) : t.include.push(c(r)), t),
+const s = (t) => t.split(/[\s,]+/).filter(Boolean).reduce(
+  (e, r) => (r[0] === "-" ? e.exclude.push(c(r.slice(1))) : e.include.push(c(r)), e),
   { include: [], exclude: [] }
-), n = (s, e) => s.exclude.every((t) => !t.test(e)) && s.include.some((t) => t.test(e)), c = (s) => {
-  const e = s.replace(/\*/g, ".*?");
-  return new RegExp(`^${e}$`);
+), i = (t, n) => t.exclude.every((e) => !e.test(n)) && t.include.some((e) => e.test(n)), c = (t) => {
+  const n = t.replace(/\*/g, ".*?");
+  return new RegExp(`^${n}$`);
 };
-class i {
-  constructor(e) {
-    this.pattern = e.pattern, this.processor = e.processor, this.filters = o(e.pattern);
-  }
-  processLog(e) {
-    n(this.filters, e.origin.join(":")) && this.processor.processLog(e);
-  }
+function l({
+  processor: t,
+  pattern: n
+}) {
+  const e = s(n);
+  return (r) => {
+    i(e, r.origin.join(":")) && t(r);
+  };
 }
 export {
-  i as PatternFilter,
-  i as default
+  l as createPatternFilter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holz/pattern-filter",
-  "version": "0.2.0",
+  "version": "0.6.0",
   "description": "Only print log messages that match a pattern",
   "type": "module",
   "main": "./dist/holz-pattern-filter.cjs",
@@ -40,9 +40,9 @@
     "test:types": "tsc"
   },
   "devDependencies": {
-    "@holz/core": "0.2.0",
-    "@vitest/coverage-c8": "0.28.5",
-    "typescript": "4.9.5",
+    "@holz/core": "^0.6.0",
+    "@vitest/coverage-c8": "^0.28.5",
+    "typescript": "^4.9.5",
     "vite": "^4.0.0",
     "vitest": "^0.28.5"
   }

package/src/__tests__/pattern-filter.test.ts

@@ -1,15 +1,10 @@
-import type { LogProcessor } from '@holz/core';
 import { createLogger } from '@holz/core';
-import PatternFilter from '../pattern-filter';
-
-class TestBackend implements LogProcessor {
-  processLog = vi.fn();
-}
+import { createPatternFilter } from '../pattern-filter';
 
 describe('PatternFilter', () => {
   it('only passes through logs that have the filter', () => {
-    const backend = new TestBackend();
-    const filter = new PatternFilter({
+    const backend = vi.fn();
+    const filter = createPatternFilter({
       pattern: '-ignored, -*:wild, *',
       processor: backend,
     });
@@ -17,13 +12,13 @@ describe('PatternFilter', () => {
     const logger = createLogger(filter);
 
     logger.namespace('ignored').info('excluded by filter');
-    expect(backend.processLog).not.toHaveBeenCalled();
+    expect(backend).not.toHaveBeenCalled();
 
     logger.namespace('something').namespace('wild').info('also excluded');
-    expect(backend.processLog).not.toHaveBeenCalled();
+    expect(backend).not.toHaveBeenCalled();
 
     logger.namespace('app').info('not ignored');
-    expect(backend.processLog).toHaveBeenCalledWith(
+    expect(backend).toHaveBeenCalledWith(
       expect.objectContaining({
         message: 'not ignored',
       })
@@ -31,12 +26,12 @@ describe('PatternFilter', () => {
   });
 
   it('does not send anything by default', () => {
-    const backend = new TestBackend();
-    const filter = new PatternFilter({ pattern: '', processor: backend });
+    const backend = vi.fn();
+    const filter = createPatternFilter({ pattern: '', processor: backend });
     const logger = createLogger(filter);
 
     logger.info('no include patterns mean this is ignored');
 
-    expect(backend.processLog).not.toHaveBeenCalled();
+    expect(backend).not.toHaveBeenCalled();
   });
 });

package/src/index.ts

@@ -1 +1 @@
-export { default, default as PatternFilter } from './pattern-filter';
+export { createPatternFilter } from './pattern-filter';

package/src/pattern-filter.ts

@@ -11,27 +11,22 @@ import { parse, matches } from './string-match';
  * with the origin `my-app`.
  *
  * @example
- * new PatternFilter({
+ * createPatternFilter({
  *   pattern: 'my-app*, -spammy:library',
  *   processor: backend,
  * })
  */
-export default class PatternFilter implements LogProcessor {
-  private filters: ReturnType<typeof parse>;
-  readonly pattern: string;
-  private processor: LogProcessor;
+export function createPatternFilter({
+  processor,
+  pattern,
+}: Config): LogProcessor {
+  const filters = parse(pattern);
 
-  constructor(config: Config) {
-    this.pattern = config.pattern;
-    this.processor = config.processor;
-    this.filters = parse(config.pattern);
-  }
-
-  processLog(log: Log) {
-    if (matches(this.filters, log.origin.join(':'))) {
-      this.processor.processLog(log);
+  return (log: Log) => {
+    if (matches(filters, log.origin.join(':'))) {
+      processor(log);
     }
-  }
+  };
 }
 
 interface Config {