@holz/pattern-filter 0.7.0 → 0.8.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jesse Gibson
+
+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/holz-pattern-filter.cjs

@@ -1 +1 @@
-"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;
+"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:[]}),l=(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}$`)},i=({processor:t,pattern:r})=>{const e=s(r);return n=>{l(e,n.origin.join(":"))&&t(n)}};exports.createPatternFilter=i;

package/dist/holz-pattern-filter.d.ts

@@ -22,6 +22,6 @@ declare interface Config {
  *   processor: backend,
  * })
  */
-export declare function createPatternFilter({ processor, pattern, }: Config): LogProcessor;
+export declare const createPatternFilter: ({ processor, pattern, }: Config) => LogProcessor;
 
 export { }

package/dist/holz-pattern-filter.js

@@ -1,19 +1,18 @@
 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: [] }
-), i = (t, n) => t.exclude.every((e) => !e.test(n)) && t.include.some((e) => e.test(n)), c = (t) => {
+), l = (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}$`);
-};
-function l({
+}, i = ({
   processor: t,
   pattern: n
-}) {
+}) => {
   const e = s(n);
   return (r) => {
-    i(e, r.origin.join(":")) && t(r);
+    l(e, r.origin.join(":")) && t(r);
   };
-}
+};
 export {
-  l as createPatternFilter
+  i as createPatternFilter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holz/pattern-filter",
-  "version": "0.7.0",
+  "version": "0.8.2",
   "description": "Only print log messages that match a pattern",
   "type": "module",
   "repository": {
@@ -22,8 +22,7 @@
   "license": "MIT",
   "sideEffects": false,
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "keywords": [
     "holz",
@@ -38,15 +37,16 @@
     "test:types": "tsc"
   },
   "peerDependencies": {
-    "@holz/core": "0.7.0"
+    "@holz/core": "^0.8.0"
   },
   "devDependencies": {
-    "@holz/core": "^0.7.0",
+    "@holz/core": "^0.8.2",
     "@vitest/coverage-v8": "^3.0.8",
-    "typescript": "^5.0.0",
+    "typescript": "^5.8.2",
     "vite": "^6.0.0",
     "vite-plugin-dts": "^4.5.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.0.8"
-  }
-}
+  },
+  "gitHead": "f099a09cd01834de9bc1714908183cbb7b828c85"
+}

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

@@ -1,37 +0,0 @@
-import { createLogger } from '@holz/core';
-import { createPatternFilter } from '../pattern-filter';
-
-describe('PatternFilter', () => {
-  it('only passes through logs that have the filter', () => {
-    const backend = vi.fn();
-    const filter = createPatternFilter({
-      pattern: '-ignored, -*:wild, *',
-      processor: backend,
-    });
-
-    const logger = createLogger(filter);
-
-    logger.namespace('ignored').info('excluded by filter');
-    expect(backend).not.toHaveBeenCalled();
-
-    logger.namespace('something').namespace('wild').info('also excluded');
-    expect(backend).not.toHaveBeenCalled();
-
-    logger.namespace('app').info('not ignored');
-    expect(backend).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: 'not ignored',
-      }),
-    );
-  });
-
-  it('does not send anything by default', () => {
-    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).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/string-match.test.ts

@@ -1,56 +0,0 @@
-import { parse, matches } from '../string-match';
-
-describe('string-match', () => {
-  describe('parse', () => {
-    it('parses include patterns', () => {
-      expect(parse('  foo,bar baz  , qux  ')).toEqual({
-        include: [/^foo$/, /^bar$/, /^baz$/, /^qux$/],
-        exclude: [],
-      });
-    });
-
-    it('detects and groups exclusion patterns', () => {
-      expect(parse('first,-second,-third,fourth')).toEqual({
-        include: [/^first$/, /^fourth$/],
-        exclude: [/^second$/, /^third$/],
-      });
-    });
-
-    it('converts star patterns to regex wildcards', () => {
-      expect(parse('first,second*,split*part')).toEqual({
-        include: [/^first$/, /^second.*?$/, /^split.*?part$/],
-        exclude: [],
-      });
-    });
-  });
-
-  describe('matches', () => {
-    it('returns true if the pattern matches', () => {
-      expect(matches(parse('hello'), 'hello')).toBe(true);
-    });
-
-    it('returns true if the pattern matches a wildcard', () => {
-      expect(matches(parse('hello*'), 'hello world')).toBe(true);
-    });
-
-    it('returns false if the pattern does not match', () => {
-      expect(matches(parse('hello'), 'bar')).toBe(false);
-    });
-
-    it('returns false if the pattern is excluded', () => {
-      expect(matches(parse('-hello'), 'hello')).toBe(false);
-    });
-
-    it('returns true if the pattern is included', () => {
-      expect(matches(parse('hello'), 'hello')).toBe(true);
-    });
-
-    it('does not match if there is a contradiction', () => {
-      expect(matches(parse('maybe,-maybe'), 'maybe')).toBe(false);
-    });
-
-    it('does not match if the filter is empty', () => {
-      expect(matches(parse(''), 'content')).toBe(false);
-    });
-  });
-});

package/src/index.ts

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

package/src/pattern-filter.ts

@@ -1,38 +0,0 @@
-import type { Log, LogProcessor } from '@holz/core';
-import { parse, matches } from './string-match';
-
-/**
- * Only forwards logs who's origin matches the given pattern. It works the
- * same as the popular `debug` module.
- *
- * Patterns allow wildcards and negation. For example, the pattern `my-app*`
- * will match all logs with the origin `my-app` or `my-app:foo` or
- * `my-app:foo:bar`. The pattern `*, -my-app` will match all logs except those
- * with the origin `my-app`.
- *
- * @example
- * createPatternFilter({
- *   pattern: 'my-app*, -spammy:library',
- *   processor: backend,
- * })
- */
-export function createPatternFilter({
-  processor,
-  pattern,
-}: Config): LogProcessor {
-  const filters = parse(pattern);
-
-  return (log: Log) => {
-    if (matches(filters, log.origin.join(':'))) {
-      processor(log);
-    }
-  };
-}
-
-interface Config {
-  /** A set of patterns to test against `log.origin`. */
-  pattern: string;
-
-  /** Where to send logs if they pass the filter. */
-  processor: LogProcessor;
-}

package/src/string-match.ts

@@ -1,42 +0,0 @@
-/**
- * Parse a string of multiple patterns into a set of regular expressions. We
- * use a pattern string (instead of regexes) because it's easier to persist in
- * storage or specify through a CLI.
- *
- * Special thanks to `debug-js` for the inspiration. I read their code as
- * a guide for this implementation.
- */
-export const parse = (input: string): PatternFilters => {
-  const patterns = input.split(/[\s,]+/).filter(Boolean);
-
-  return patterns.reduce<PatternFilters>(
-    (groups, pattern) => {
-      if (pattern[0] === '-') {
-        groups.exclude.push(toRegex(pattern.slice(1)));
-      } else {
-        groups.include.push(toRegex(pattern));
-      }
-
-      return groups;
-    },
-    { include: [], exclude: [] },
-  );
-};
-
-/** Detect if a string matches a set of patterns. */
-export const matches = (filters: PatternFilters, input: string): boolean => {
-  return (
-    filters.exclude.every((pattern) => !pattern.test(input)) &&
-    filters.include.some((pattern) => pattern.test(input))
-  );
-};
-
-const toRegex = (pattern: string): RegExp => {
-  const regex = pattern.replace(/\*/g, '.*?');
-  return new RegExp(`^${regex}$`);
-};
-
-interface PatternFilters {
-  include: Array<RegExp>;
-  exclude: Array<RegExp>;
-}