glob-to-regex.js 1.0.1 → 1.2.0

package/README.md

@@ -46,6 +46,13 @@ match('types.d.ts');  // true (negation is not parsed specially)
 - `**` matches across path segments, including none
 - `{a,b,c}` alternation groups (no nesting). Each item inside can itself contain glob syntax
 - Character classes: `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]`
+- **Extended globbing** (when `extglob: true` option is set):
+  - `?(pattern-list)` matches zero or one occurrence of the given patterns
+  - `*(pattern-list)` matches zero or more occurrences of the given patterns
+  - `+(pattern-list)` matches one or more occurrences of the given patterns
+  - `@(pattern-list)` matches exactly one of the given patterns
+  - `!(pattern-list)` matches anything except one of the given patterns
+  - Pattern lists use `|` as separator (e.g., `@(jpg|png|gif)`)
 
 Notes:
 - The produced RegExp is anchored at start and end (`^...$`).
@@ -66,6 +73,15 @@ toRegex('src/{a,b}/**/*.ts').test('src/b/x/y.ts'); // true
 toRegex('file[0-9].txt').test('file5.txt');        // true
 toRegex('file[!0-9].txt').test('filea.txt');       // true
 toRegex('**/*.[jt]s{,x}').test('dir/a/b.jsx');     // true
+
+// Extended globbing examples
+toRegex('file?(s).txt', {extglob: true}).test('file.txt');  // true
+toRegex('file?(s).txt', {extglob: true}).test('files.txt'); // true
+toRegex('file.@(jpg|png|gif)', {extglob: true}).test('file.jpg'); // true
+toRegex('/var/log/!(*.gz)', {extglob: true}).test('/var/log/syslog'); // true
+toRegex('/var/log/!(*.gz)', {extglob: true}).test('/var/log/error.log.gz'); // false
+toRegex('src/**/!(*.test).js', {extglob: true}).test('src/app.test.js'); // false
+toRegex('src/**/!(*.test).js', {extglob: true}).test('src/index.js'); // true
 ```
 
 ## TypeScript

package/lib/index.d.ts

@@ -1,3 +1,9 @@
+export interface GlobOptions {
+    /** Treat pattern as case insensitive */
+    nocase?: boolean;
+    /** Enable extended globbing: ?(pattern), *(pattern), +(pattern), @(pattern), !(pattern) */
+    extglob?: boolean;
+}
 /**
  * Convert a glob pattern to a regular expression
  *
@@ -8,8 +14,14 @@
  * - `**` to match any number of path segments, including none
  * - `{}` to group conditions (e.g. `{html,txt}`)
  * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]` character classes
+ * - Extended globbing (when `extglob: true` option is set):
+ *   - `?(pattern-list)` zero or one occurrence
+ *   - `*(pattern-list)` zero or more occurrences
+ *   - `+(pattern-list)` one or more occurrences
+ *   - `@(pattern-list)` exactly one of the patterns
+ *   - `!(pattern-list)` anything except the patterns
  */
-export declare const toRegex: (pattern: string) => RegExp;
+export declare const toRegex: (pattern: string, options?: GlobOptions) => RegExp;
 /**
  * A glob pattern to match files paths against. An array or a single pattern
  * can be provided, if an array is given, then individual patterns will be
@@ -21,4 +33,4 @@ export declare const toRegex: (pattern: string) => RegExp;
  */
 export type Pattern = string | RegExp | (string | RegExp)[];
 export type Matcher = (path: string) => boolean;
-export declare const toMatcher: (pattern: Pattern) => Matcher;
+export declare const toMatcher: (pattern: Pattern, options?: GlobOptions) => Matcher;

package/lib/index.js

@@ -2,6 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toMatcher = exports.toRegex = void 0;
 const escapeRe = (ch) => (/[.^$+{}()|\\]/.test(ch) ? `\\${ch}` : ch);
+/**
+ * Parse an extended glob pattern like ?(a|b|c)
+ * Returns the regex string equivalent and the new index position
+ */
+const parseExtGlob = (pattern, startIdx, prefix, options) => {
+    let i = startIdx; // startIdx should be pointing at the character after '('
+    const parts = [];
+    let cur = '';
+    let depth = 1; // Track parenthesis depth for nested patterns
+    while (i < pattern.length && depth > 0) {
+        const ch = pattern[i];
+        if (ch === '(') {
+            depth++;
+            cur += ch;
+            i++;
+        }
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0) {
+                // Found the closing parenthesis
+                parts.push(cur);
+                i++; // consume ')'
+                break;
+            }
+            else {
+                cur += ch;
+                i++;
+            }
+        }
+        else if (ch === '|' && depth === 1) {
+            // Pipe separator at top level of this extglob
+            parts.push(cur);
+            cur = '';
+            i++;
+        }
+        else {
+            cur += ch;
+            i++;
+        }
+    }
+    if (depth !== 0)
+        return; // Unclosed parenthesis
+    let alternatives = '';
+    const length = parts.length;
+    for (let j = 0; j < length; j++)
+        alternatives += (alternatives ? '|' : '') + (0, exports.toRegex)(parts[j], options).source.replace(/^\^/, '').replace(/\$$/, '');
+    switch (prefix) {
+        case '?': // zero or one
+            return [`(?:${alternatives})?`, i];
+        case '*': // zero or more
+            return [`(?:${alternatives})*`, i];
+        case '+': // one or more
+            return [`(?:${alternatives})+`, i];
+        case '@': // exactly one
+            return [`(?:${alternatives})`, i];
+        case '!': // none of (negative match)
+            // For negation, we need to match anything that doesn't match the pattern
+            // Use negative lookahead without consuming characters after
+            return [`(?!${alternatives})[^/]*`, i];
+    }
+    return;
+};
 /**
  * Convert a glob pattern to a regular expression
  *
@@ -12,8 +74,14 @@ const escapeRe = (ch) => (/[.^$+{}()|\\]/.test(ch) ? `\\${ch}` : ch);
  * - `**` to match any number of path segments, including none
  * - `{}` to group conditions (e.g. `{html,txt}`)
  * - `[abc]`, `[a-z]`, `[!a-z]`, `[!abc]` character classes
+ * - Extended globbing (when `extglob: true` option is set):
+ *   - `?(pattern-list)` zero or one occurrence
+ *   - `*(pattern-list)` zero or more occurrences
+ *   - `+(pattern-list)` one or more occurrences
+ *   - `@(pattern-list)` exactly one of the patterns
+ *   - `!(pattern-list)` anything except the patterns
  */
-const toRegex = (pattern) => {
+const toRegex = (pattern, options) => {
     let regexStr = '';
     let i = 0;
     // Helper to parse a brace group like {a,b,c}. No nesting support.
@@ -45,11 +113,24 @@ const toRegex = (pattern) => {
             return '\\{' + escapeRe(cur);
         }
         // Convert each part recursively to support globs inside braces
-        const alt = parts.map((p) => (0, exports.toRegex)(p).source.replace(/^\^/, '').replace(/\$$/, '')).join('|');
+        const alt = parts.map((p) => (0, exports.toRegex)(p, options).source.replace(/^\^/, '').replace(/\$$/, '')).join('|');
         return `(?:${alt})`;
     };
+    const extglob = !!options?.extglob;
     while (i < pattern.length) {
         const char = pattern[i];
+        // Check for extended glob patterns when extglob is enabled
+        if (extglob && pattern[i + 1] === '(') {
+            if (char === '?' || char === '*' || char === '+' || char === '@' || char === '!') {
+                const result = parseExtGlob(pattern, i + 2, char, options);
+                if (result) {
+                    regexStr += result[0];
+                    i = result[1];
+                    continue;
+                }
+                // If parse failed, fall through to normal handling
+            }
+        }
         switch (char) {
             case '*': {
                 // Check for double star **
@@ -134,11 +215,12 @@ const toRegex = (pattern) => {
                 break;
         }
     }
-    return new RegExp('^' + regexStr + '$');
+    const flags = options?.nocase ? 'i' : '';
+    return new RegExp('^' + regexStr + '$', flags);
 };
 exports.toRegex = toRegex;
 const isRegExp = /^\/(.{1,4096})\/([gimsuy]{0,6})$/;
-const toMatcher = (pattern) => {
+const toMatcher = (pattern, options) => {
     const regexes = [];
     const patterns = Array.isArray(pattern) ? pattern : [pattern];
     for (const pat of patterns) {
@@ -149,19 +231,15 @@ const toMatcher = (pattern) => {
                 regexes.push(new RegExp(expr, flags));
             }
             else {
-                regexes.push((0, exports.toRegex)(pat));
+                regexes.push((0, exports.toRegex)(pat, options));
             }
         }
         else {
             regexes.push(pat);
         }
     }
-    const length = regexes.length;
-    return (path) => {
-        for (let i = 0; i < length; i++)
-            if (regexes[i].test(path))
-                return true;
-        return false;
-    };
+    return regexes.length
+        ? new Function('p', 'return ' + regexes.map((r) => r + '.test(p)').join('||'))
+        : () => false;
 };
 exports.toMatcher = toMatcher;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "glob-to-regex.js",
-  "packageManager": "yarn@4.9.3",
+  "packageManager": "yarn@4.9.4",
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Transform GLOB patterns to JavaScript regular expressions for fast file path matching.",
   "author": {
     "name": "streamich",