@holz/pattern-filter 0.8.2 → 0.8.3-rc.152

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:[]}),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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=e=>e.split(/[\s,]+/).filter(Boolean).reduce((e,t)=>(t[0]===`-`?e.exclude.push(n(t.slice(1))):e.include.push(n(t)),e),{include:[],exclude:[]}),t=(e,t)=>e.exclude.every(e=>!e.test(t))&&e.include.some(e=>e.test(t)),n=e=>{let t=e.replace(/\*/g,`.*?`);return RegExp(`^${t}$`)},r=({processor:n,pattern:r})=>{let i=e(r);return e=>{t(i,e.origin.join(`:`))&&n(e)}};exports.createPatternFilter=r;

package/dist/holz-pattern-filter.js

@@ -1,18 +1,15 @@
-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: [] }
-), 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}$`);
-}, i = ({
-  processor: t,
-  pattern: n
-}) => {
-  const e = s(n);
-  return (r) => {
-    l(e, r.origin.join(":")) && t(r);
-  };
-};
-export {
-  i as createPatternFilter
+//#region src/string-match.ts
+var e = (e) => e.split(/[\s,]+/).filter(Boolean).reduce((e, t) => (t[0] === "-" ? e.exclude.push(n(t.slice(1))) : e.include.push(n(t)), e), {
+	include: [],
+	exclude: []
+}), t = (e, t) => e.exclude.every((e) => !e.test(t)) && e.include.some((e) => e.test(t)), n = (e) => {
+	let t = e.replace(/\*/g, ".*?");
+	return RegExp(`^${t}$`);
+}, r = ({ processor: n, pattern: r }) => {
+	let i = e(r);
+	return (e) => {
+		t(i, e.origin.join(":")) && n(e);
+	};
 };
+//#endregion
+export { r as createPatternFilter };

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/src/index.d.ts

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

package/dist/{holz-pattern-filter.d.ts → src/pattern-filter.d.ts}

@@ -1,27 +1,24 @@
-import { LogProcessor } from '@holz/core';
-
-declare interface Config {
-    /** A set of patterns to test against `log.origin`. */
-    pattern: string;
-    /** Where to send logs if they pass the filter. */
-    processor: LogProcessor;
-}
-
-/**
- * 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 declare const createPatternFilter: ({ processor, pattern, }: Config) => LogProcessor;
-
-export { }
+import { LogProcessor } from '@holz/core';
+/**
+ * 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 declare const createPatternFilter: ({ processor, pattern, }: Config) => LogProcessor;
+interface Config {
+    /** A set of patterns to test against `log.origin`. */
+    pattern: string;
+    /** Where to send logs if they pass the filter. */
+    processor: LogProcessor;
+}
+export {};

package/dist/src/string-match.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare const parse: (input: string) => PatternFilters;
+/** Detect if a string matches a set of patterns. */
+export declare const matches: (filters: PatternFilters, input: string) => boolean;
+interface PatternFilters {
+    include: Array<RegExp>;
+    exclude: Array<RegExp>;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holz/pattern-filter",
-  "version": "0.8.2",
+  "version": "0.8.3-rc.152+a4ea736",
   "description": "Only print log messages that match a pattern",
   "type": "module",
   "repository": {
@@ -33,20 +33,20 @@
   ],
   "scripts": {
     "prepack": "vite build",
-    "test:unit": "vitest --color --passWithNoTests",
+    "test:unit": "vitest run --color --passWithNoTests",
     "test:types": "tsc"
   },
   "peerDependencies": {
     "@holz/core": "^0.8.0"
   },
   "devDependencies": {
-    "@holz/core": "^0.8.2",
-    "@vitest/coverage-v8": "^3.0.8",
-    "typescript": "^5.8.2",
-    "vite": "^6.0.0",
-    "vite-plugin-dts": "^4.5.3",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.8"
+    "@holz/core": "^0.8.3-rc.152+a4ea736",
+    "@vitest/coverage-v8": "^4.0.0",
+    "typescript": "^6.0.0",
+    "vite": "^8.0.0",
+    "vite-plugin-dts": "^5.0.0",
+    "vite-tsconfig-paths": "^6.0.0",
+    "vitest": "^4.0.0"
   },
-  "gitHead": "f099a09cd01834de9bc1714908183cbb7b828c85"
+  "gitHead": "a4ea7361cad7340841a12ca7c7366ffbd25eaa35"
 }