@reliverse/matcha 2.2.7

package/README.md

@@ -0,0 +1,210 @@
+# @reliverse/matcha
+
+> @reliverse/matcha is a high-performance minimal glob matcher, with micromatch-level power, zepto-level size, and reliverse-grade dx.
+
+[sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/reliverse) — [npm](https://npmjs.com/package/@reliverse/matcha) — [github](https://github.com/reliverse/matcha)
+
+## Installation
+
+```bash
+bun add @reliverse/matcha
+# bun • pnpm • yarn • npm
+```
+
+## Features
+
+You want **micromatch/picomatch features** in a **zeptomatch-sized**(🔜) package.
+
+- 🧩 Drop-in replacement for `micromatch`, `zeptomatch`, `picomatch`
+- 🧠 Full bash-style globbing support with advanced pattern matching
+- 🪶 Tiny ([7.5 kB](https://bundlephobia.com/package/@reliverse/matcha@latest)), tree-shakeable, dependency-free implementation
+- ⚡ Fast runtime with optimized regex compilation and caching
+- 🔧 Complete toolset: escape, parse, compile, and match
+- 🔜 1700+ picomatch and zeptomatch tests passed
+- 🪄 Rich feature set with intuitive API
+
+## Features in Detail
+
+### Core Pattern Matching
+
+- **Wildcards**
+  - `*` - Matches any characters except path separators
+  - `**` - Matches any characters including path separators (globstar)
+  - `?` - Matches exactly one character except path separators
+
+### Advanced Pattern Matching
+
+- **Character Classes**
+  - `[abc]` - Matches any single character from the set
+  - `[a-z]` - Matches any single character in the range
+  - `[!abc]` or `[^abc]` - Matches any single character not in the set
+  
+- **Brace Expansion**
+  - `{a,b,c}` - Matches any of the comma-separated patterns
+  - Nested braces supported: `{a,{b,c}}` expands correctly
+  - Numeric ranges: `{1..5}` matches 1,2,3,4,5
+  - Padded numeric ranges: `{01..05}` matches 01,02,03,04,05
+  - Alphabetic ranges: `{a..e}` matches a,b,c,d,e
+  - Case-sensitive alphabetic ranges: `{A..E}` vs `{a..e}`
+
+- **Pattern Negation**
+  - `!pattern` - Matches anything that doesn't match the pattern
+  - Multiple negations: `!!pattern` (negates the negation)
+  - Combining with other patterns: `['*.js', '!test.js']`
+
+### Special Features
+
+- **Dot File Handling**
+  - By default, `*` won't match files starting with a dot
+  - Explicit dot matching with `.*.js` or setting `dot: true` option
+  
+- **Path Handling**
+  - Automatic path normalization (converts backslashes to forward slashes)
+  - Proper handling of path separators in globstar patterns
+
+### Performance Optimizations
+
+- **Pattern Compilation**
+  - Automatic caching of compiled patterns
+  - Efficient regex generation with optimized character classes
+  - Smart handling of static vs dynamic patterns
+
+- **Memory Efficiency**
+  - Minimal memory footprint
+  - Efficient pattern parsing and compilation
+  - Smart caching strategies
+
+## API Reference
+
+### Main Function
+
+```typescript
+// Returns true if input matches pattern(s)
+matcha(pattern: string, input: string, options?: matchaOptions): boolean
+matcha(patterns: string[], input: string, options?: matchaOptions): boolean
+
+// Returns a compiled matcher function
+matcha(pattern: string, options?: matchaOptions): Matcher
+matcha(patterns: string[], options?: matchaOptions): Matcher
+```
+
+#### Options
+
+```typescript
+interface matchaOptions {
+  dot?: boolean;      // Match dotfiles (default: false)
+  nocase?: boolean;   // Case-insensitive matching (default: false)
+  ignore?: string | string[]; // Patterns to ignore (applies to input)
+}
+```
+
+#### Types
+
+```typescript
+type Matcher = (input: string) => boolean;
+
+type ScanResult = {
+  isGlob: boolean;
+  negated: boolean;
+  glob: string;
+  parts?: string[];
+};
+```
+
+### Utility Functions
+
+All utility functions are available as named exports and as properties on the default export:
+
+```typescript
+compile(pattern: string, options?: matchaOptions): Matcher
+makeRegex(pattern: string, options?: matchaOptions): RegExp
+makeRe(pattern: string, options?: matchaOptions): RegExp // Alias for makeRegex
+normalizePath(pathStr: string): string
+escapeGlob(str: string): string
+unescapeGlob(str: string): string
+isStatic(pattern: string, options?: { dot?: boolean }): boolean
+scan(pattern: string, options?: { parts?: boolean }): ScanResult
+explode(pattern: string): { static: string[]; dynamic: string[] }
+```
+
+## Examples
+
+```typescript
+import matcha, { compile, normalizePath } from "@reliverse/matcha";
+
+// Basic matching
+matcha("*.js", "file.js");                  // → true
+matcha("**/*.js", "src/utils/file.js");     // → true
+matcha("*.js", "file.ts");                  // → false
+
+// Dot files
+matcha("*.js", ".hidden.js");               // → false
+matcha("*.js", ".hidden.js", { dot: true }); // → true
+
+// Case-insensitive matching
+matcha("*.JS", "file.js", { nocase: true }); // → true
+
+// Character classes
+matcha("[abc].js", "a.js");                 // → true
+matcha("[!a-z].js", "9.js");                // → true
+
+// Brace expansion
+matcha("file.{js,ts}", "file.js");          // → true
+matcha("file{1..3}.js", "file2.js");        // → true
+matcha("file{01..03}.js", "file01.js");     // → true
+
+// Multiple patterns and negation
+matcha(["*.js", "!test.js"], "file.js");    // → true
+matcha(["*.js", "!file.js"], "file.js");    // → false
+
+// Ignore option
+matcha("*.js", "file.js", { ignore: "file.js" }); // → false
+matcha(["*.js", "!test.js"], "test.js", { ignore: "test.js" }); // → false
+
+// Compiled matcher
+const matcher = compile("**/*.{js,ts}");
+matcher("src/file.js");                      // → true
+matcher("deep/nested/file.ts");              // → true
+
+// Path normalization (for Windows paths)
+matcha("src/*.js", "src\\file.js");         // → true
+normalizePath("src\\file.js");               // → "src/file.js"
+
+// Utility: escape/unescape
+matcha(escapeGlob("file[1].js"), "file[1].js"); // → true
+unescapeGlob("file\\[1\\].js");                // → "file[1].js"
+
+// Utility: isStatic, scan, explode
+isStatic("file.js");                         // → true
+isStatic("*.js");                            // → false
+scan("!src/*.js");                           // → { isGlob: true, negated: true, glob: "src/*.js" }
+explode("src/file[1-3].js");                 // → { static: ["src/file"], dynamic: ["[1-3].js"] }
+```
+
+## Playground
+
+To test [example/e-mod.ts](./example/e-mod.ts), run:
+
+```bash
+git clone https://github.com/reliverse/matcha
+cd matcha
+bun i
+bun dev # beginner-friendly example
+bun tests # advanced test suite
+```
+
+## Contributing
+
+- 🧙 Star it on [GitHub](https://github.com/reliverse/matcha)
+- 💬 Join our [Discord](https://discord.gg/reliverse)
+- 💖 [Sponsor @blefnk](https://github.com/sponsors/blefnk)
+
+## Related Reliverse Projects
+
+- [`@reliverse/reglob`](https://npmjs.com/package/@reliverse/reglob) — Tiny, fast globber
+- [`@reliverse/relifso`](https://npmjs.com/package/@reliverse/relifso) — Filesystem made fun again
+- [`@reliverse/repackr`](https://npmjs.com/package/@reliverse/repackr) — Alternative to tar/7zip
+
+## License
+
+💖 [MIT](./LICENSE) © [blefnk (Nazar Kornienko)](https://github.com/blefnk)

package/dist/mod.d.ts

@@ -0,0 +1,129 @@
+interface MatchOptions {
+    partial?: boolean;
+}
+interface CompileOptions {
+    partial?: boolean;
+}
+interface MatcherOptions {
+    partial?: boolean;
+}
+/**
+ * Check if a glob pattern matches a path
+ * @param pattern - The glob pattern to match against
+ * @param input - The input string to test
+ * @param options - Optional configuration
+ * @returns True if the pattern matches the input
+ */
+export declare const match: (pattern: string, input: string, options?: MatchOptions) => boolean;
+/**
+ * Check if a glob pattern matches a path (alias for match)
+ * @param pattern - The glob pattern to match against
+ * @param input - The input string to test
+ * @param options - Optional configuration
+ * @returns True if the pattern matches the input
+ */
+export declare const isMatch: (pattern: string, input: string, options?: MatchOptions) => boolean;
+/**
+ * Create a matcher function for a specific pattern
+ * @param pattern - The glob pattern to compile
+ * @param options - Optional configuration
+ * @returns A function that tests input against the pattern
+ */
+export declare const createMatcher: (pattern: string, options?: MatcherOptions) => (input: string) => boolean;
+/**
+ * Create multiple matcher functions for multiple patterns
+ * @param patterns - Array of glob patterns to compile
+ * @param options - Optional configuration
+ * @returns Array of matcher functions
+ */
+export declare const createMatchers: (patterns: string[], options?: MatcherOptions) => ((input: string) => boolean)[];
+/**
+ * Test if any of the patterns match the input
+ * @param patterns - Array of glob patterns to test
+ * @param input - The input string to test
+ * @param options - Optional configuration
+ * @returns True if any pattern matches
+ */
+export declare const matchAny: (patterns: string[], input: string, options?: MatchOptions) => boolean;
+/**
+ * Test if all patterns match the input
+ * @param patterns - Array of glob patterns to test
+ * @param input - The input string to test
+ * @param options - Optional configuration
+ * @returns True if all patterns match
+ */
+export declare const matchAll: (patterns: string[], input: string, options?: MatchOptions) => boolean;
+/**
+ * Filter an array of strings based on glob patterns
+ * @param patterns - Array of glob patterns to match against
+ * @param inputs - Array of strings to filter
+ * @param options - Optional configuration
+ * @returns Array of strings that match any of the patterns
+ */
+export declare const filter: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
+/**
+ * Filter an array of strings, excluding those that match glob patterns
+ * @param patterns - Array of glob patterns to exclude
+ * @param inputs - Array of strings to filter
+ * @param options - Optional configuration
+ * @returns Array of strings that don't match any of the patterns
+ */
+export declare const exclude: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
+/**
+ * Compile a glob pattern to a regular expression
+ * @param pattern - The glob pattern to compile
+ * @param options - Optional configuration
+ * @returns Compiled regular expression
+ */
+export declare const compile: (pattern: string, options?: CompileOptions) => RegExp;
+/**
+ * Compile multiple glob patterns to a single regular expression
+ * @param patterns - Array of glob patterns to compile
+ * @param options - Optional configuration
+ * @returns Compiled regular expression that matches any of the patterns
+ */
+export declare const compileAny: (patterns: string[], options?: CompileOptions) => RegExp;
+/**
+ * Normalize glob patterns by splitting on whitespace and filtering empty strings
+ * @param patterns - String or array of patterns to normalize
+ * @returns Normalized array of patterns
+ */
+export declare const normalizePatterns: (patterns: string | string[]) => string[];
+/**
+ * Create a filter function that excludes patterns
+ * @param ignorePatterns - Patterns to ignore (string or array)
+ * @param options - Optional configuration
+ * @returns Function that filters out matching items
+ */
+export declare const createIgnoreFilter: (ignorePatterns: string | string[], options?: MatcherOptions) => <T extends {
+    name: string;
+}>(items: T[]) => T[];
+/**
+ * Create a filter function that includes only matching patterns
+ * @param includePatterns - Patterns to include (string or array)
+ * @param options - Optional configuration
+ * @returns Function that filters to only matching items
+ */
+export declare const createIncludeFilter: (includePatterns: string | string[], options?: MatcherOptions) => <T extends {
+    name: string;
+}>(items: T[]) => T[];
+declare const _default: {
+    match: (pattern: string, input: string, options?: MatchOptions) => boolean;
+    isMatch: (pattern: string, input: string, options?: MatchOptions) => boolean;
+    createMatcher: (pattern: string, options?: MatcherOptions) => (input: string) => boolean;
+    createMatchers: (patterns: string[], options?: MatcherOptions) => ((input: string) => boolean)[];
+    matchAny: (patterns: string[], input: string, options?: MatchOptions) => boolean;
+    matchAll: (patterns: string[], input: string, options?: MatchOptions) => boolean;
+    filter: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
+    exclude: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
+    compile: (pattern: string, options?: CompileOptions) => RegExp;
+    compileAny: (patterns: string[], options?: CompileOptions) => RegExp;
+    normalizePatterns: (patterns: string | string[]) => string[];
+    createIgnoreFilter: (ignorePatterns: string | string[], options?: MatcherOptions) => <T extends {
+        name: string;
+    }>(items: T[]) => T[];
+    createIncludeFilter: (includePatterns: string | string[], options?: MatcherOptions) => <T extends {
+        name: string;
+    }>(items: T[]) => T[];
+};
+export default _default;

package/dist/mod.js

@@ -0,0 +1,79 @@
+import zeptomatch from "zeptomatch";
+export const match = (pattern, input, options = {}) => zeptomatch(pattern, input, options);
+export const isMatch = match;
+export const createMatcher = (pattern, options = {}) => (input) => zeptomatch(pattern, input, options);
+export const createMatchers = (patterns, options = {}) => patterns.map((pattern) => createMatcher(pattern, options));
+export const matchAny = (patterns, input, options = {}) => patterns.some((pattern) => zeptomatch(pattern, input, options));
+export const matchAll = (patterns, input, options = {}) => patterns.every((pattern) => zeptomatch(pattern, input, options));
+export const filter = (patterns, inputs, options = {}) => {
+  if (patterns.length > 1) {
+    const regex = compileAny(patterns, options);
+    return inputs.filter((input) => regex.test(input));
+  }
+  if (patterns.length === 1) {
+    const pattern = patterns[0];
+    if (pattern === void 0) return [];
+    return inputs.filter((input) => zeptomatch(pattern, input, options));
+  }
+  return [];
+};
+export const exclude = (patterns, inputs, options = {}) => {
+  if (patterns.length > 1) {
+    const regex = compileAny(patterns, options);
+    return inputs.filter((input) => !regex.test(input));
+  }
+  if (patterns.length === 1) {
+    const pattern = patterns[0];
+    if (pattern === void 0) return inputs;
+    return inputs.filter((input) => !zeptomatch(pattern, input, options));
+  }
+  return inputs;
+};
+export const compile = (pattern, options = {}) => zeptomatch.compile(pattern, options);
+export const compileAny = (patterns, options = {}) => zeptomatch.compile(patterns, options);
+export const normalizePatterns = (patterns) => Array.isArray(patterns) ? patterns.flatMap((pattern) => pattern.split(/\s+/).filter(Boolean)) : patterns.split(/\s+/).filter(Boolean);
+export const createIgnoreFilter = (ignorePatterns, options = {}) => {
+  const patterns = normalizePatterns(ignorePatterns);
+  if (patterns.length > 1) {
+    const regex = compileAny(patterns, options);
+    return (items) => items.filter((item) => !regex.test(item.name));
+  }
+  if (patterns.length === 1) {
+    const pattern = patterns[0];
+    if (pattern === void 0) {
+      return (items) => items;
+    }
+    return (items) => items.filter((item) => !zeptomatch(pattern, item.name, options));
+  }
+  return (items) => items;
+};
+export const createIncludeFilter = (includePatterns, options = {}) => {
+  const patterns = normalizePatterns(includePatterns);
+  if (patterns.length > 1) {
+    const regex = compileAny(patterns, options);
+    return (items) => items.filter((item) => regex.test(item.name));
+  }
+  if (patterns.length === 1) {
+    const pattern = patterns[0];
+    if (pattern === void 0) {
+      return (_items) => [];
+    }
+    return (items) => items.filter((item) => zeptomatch(pattern, item.name, options));
+  }
+  return (_items) => [];
+};
+export default {
+  match,
+  isMatch,
+  createMatcher,
+  createMatchers,
+  matchAny,
+  matchAll,
+  filter,
+  exclude,
+  compile,
+  compileAny,
+  normalizePatterns,
+  createIgnoreFilter,
+  createIncludeFilter
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@reliverse/matcha",
+  "version": "2.2.7",
+  "private": false,
+  "type": "module",
+  "description": "@reliverse/matcha is a high-performance minimal matcher, with micromatch-level power, zepto-level size, and reliverse-grade dx.",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
+  },
+  "dependencies": {
+    "zeptomatch": "^2.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
+}