@pattern-algebra/core 0.0.0

package/dist/parse/brace-expansion.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect } from 'vitest';
+import { parsePattern } from './parser';
+import { expandBraces, countBraceExpansions } from './brace-expansion';
+describe('expandBraces', () => {
+    it('expands simple brace expression', () => {
+        const pattern = parsePattern('{src,lib}');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(2);
+        expect(expanded[0].source).toBe('src');
+        expect(expanded[1].source).toBe('lib');
+    });
+    it('expands braces with suffix', () => {
+        const pattern = parsePattern('{src,lib}/**/*.ts');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(2);
+        expect(expanded[0].source).toBe('src/**/*.ts');
+        expect(expanded[1].source).toBe('lib/**/*.ts');
+    });
+    it('expands braces with prefix', () => {
+        const pattern = parsePattern('packages/{core,cli}');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(2);
+        expect(expanded[0].source).toBe('packages/core');
+        expect(expanded[1].source).toBe('packages/cli');
+    });
+    it('expands multiple braces', () => {
+        const pattern = parsePattern('{a,b}/{x,y}');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(4);
+        const sources = expanded.map((p) => p.source);
+        expect(sources).toContain('a/x');
+        expect(sources).toContain('a/y');
+        expect(sources).toContain('b/x');
+        expect(sources).toContain('b/y');
+    });
+    it('expands numeric range', () => {
+        const pattern = parsePattern('file{1..5}.txt');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(5);
+        expect(expanded[0].source).toBe('file1.txt');
+        expect(expanded[4].source).toBe('file5.txt');
+    });
+    it('expands descending numeric range', () => {
+        const pattern = parsePattern('v{3..1}');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(3);
+        expect(expanded[0].source).toBe('v3');
+        expect(expanded[1].source).toBe('v2');
+        expect(expanded[2].source).toBe('v1');
+    });
+    it('returns pattern unchanged if no braces', () => {
+        const pattern = parsePattern('src/**/*.ts');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(1);
+        expect(expanded[0].source).toBe('src/**/*.ts');
+    });
+    it('preserves negation', () => {
+        const pattern = parsePattern('!{node_modules,dist}/**');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(2);
+        expect(expanded[0].source).toBe('!node_modules/**');
+        expect(expanded[1].source).toBe('!dist/**');
+    });
+    it('limits expansion count', () => {
+        const pattern = parsePattern('{a,b,c,d,e}');
+        const expanded = expandBraces(pattern, 3);
+        expect(expanded.length).toBeLessThanOrEqual(3);
+        expect(expanded.some((p) => p.errors?.some((e) => e.code === 'EXPANSION_LIMIT'))).toBe(true);
+    });
+    it('limits numeric range', () => {
+        const pattern = parsePattern('{1..100}');
+        const expanded = expandBraces(pattern);
+        // Should error because range exceeds 50
+        expect(expanded.some((p) => p.errors?.some((e) => e.code === 'EXPANSION_LIMIT'))).toBe(true);
+    });
+    it('errors on nested braces', () => {
+        const pattern = parsePattern('{a,{b,c}}');
+        const expanded = expandBraces(pattern);
+        expect(expanded.some((p) => p.errors?.some((e) => e.code === 'NESTED_BRACES'))).toBe(true);
+    });
+    it('handles braces inside brackets (treated as literal)', () => {
+        // {a,b} inside [] is not brace expansion
+        const pattern = parsePattern('[{a,b}]');
+        const expanded = expandBraces(pattern);
+        expect(expanded).toHaveLength(1);
+    });
+});
+describe('countBraceExpansions', () => {
+    it('counts simple expansion', () => {
+        expect(countBraceExpansions('{a,b}')).toBe(2);
+        expect(countBraceExpansions('{a,b,c}')).toBe(3);
+    });
+    it('counts multiple braces as multiplication', () => {
+        expect(countBraceExpansions('{a,b}/{x,y}')).toBe(4);
+        expect(countBraceExpansions('{a,b}/{x,y}/{1,2}')).toBe(8);
+    });
+    it('returns 1 for no braces', () => {
+        expect(countBraceExpansions('src/**/*.ts')).toBe(1);
+    });
+    it('returns Infinity for excessive expansion', () => {
+        // Create a pattern that would expand to > 10000 (10^5 = 100,000)
+        expect(countBraceExpansions(`{a,b,c,d,e,f,g,h,i,j}{a,b,c,d,e,f,g,h,i,j}{a,b,c,d,e,f,g,h,i,j}{a,b,c,d,e,f,g,h,i,j}{a,b,c,d,e,f,g,h,i,j}`)).toBe(Infinity);
+    });
+});
+//# sourceMappingURL=brace-expansion.test.js.map

package/dist/parse/brace-expansion.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brace-expansion.test.js","sourceRoot":"","sources":["../../src/parse/brace-expansion.test.ts"],"names":[],"mappings":"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"}

package/dist/parse/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pattern parsing utilities.
+ * @packageDocumentation
+ */
+export { parsePattern } from './parser';
+export { validatePattern, isValidPattern } from './validator';
+export { expandBraces, countBraceExpansions } from './brace-expansion';
+//# sourceMappingURL=index.d.ts.map

package/dist/parse/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parse/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/parse/index.js

@@ -0,0 +1,8 @@
+/**
+ * Pattern parsing utilities.
+ * @packageDocumentation
+ */
+export { parsePattern } from './parser';
+export { validatePattern, isValidPattern } from './validator';
+export { expandBraces, countBraceExpansions } from './brace-expansion';
+//# sourceMappingURL=index.js.map

package/dist/parse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/parse/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/parse/parser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pattern parser - converts glob pattern strings to AST.
+ * @packageDocumentation
+ */
+import type { PathPattern } from '../types';
+/**
+ * Parse a pattern string into an AST.
+ *
+ * @param source - The pattern string to parse
+ * @returns Parsed PathPattern with AST and any errors
+ *
+ * @public
+ */
+export declare function parsePattern(source: string): PathPattern;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parse/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/parse/parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,WAAW,EASZ,MAAM,UAAU,CAAA;AAWjB;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CA+CxD"}

package/dist/parse/parser.js

@@ -0,0 +1,526 @@
+/**
+ * Pattern parser - converts glob pattern strings to AST.
+ * @packageDocumentation
+ */
+/**
+ * Parse a pattern string into an AST.
+ *
+ * @param source - The pattern string to parse
+ * @returns Parsed PathPattern with AST and any errors
+ *
+ * @public
+ */
+export function parsePattern(source) {
+    const state = {
+        source,
+        position: 0,
+        errors: [],
+    };
+    // Handle negation prefix
+    let isNegation = false;
+    let patternToParse = source;
+    if (source.startsWith('!')) {
+        isNegation = true;
+        patternToParse = source.slice(1);
+        state.position = 1;
+    }
+    // Determine if absolute
+    const isAbsolute = patternToParse.startsWith('/') || patternToParse.startsWith('~');
+    // Check for brace expansion at top level
+    const hasBraces = containsTopLevelBraces(patternToParse);
+    let root;
+    if (hasBraces) {
+        // Parse as alternation
+        const branches = expandBracesOnce(patternToParse, state);
+        if (branches.length === 1) {
+            root = parseSegmentSequence(branches[0], state);
+        }
+        else {
+            root = {
+                type: 'alternation',
+                branches: branches.map((branch) => parseSegmentSequence(branch, state)),
+            };
+        }
+    }
+    else {
+        root = parseSegmentSequence(patternToParse, state);
+    }
+    return {
+        source,
+        root,
+        isAbsolute,
+        isNegation,
+        errors: state.errors.length > 0 ? state.errors : undefined,
+    };
+}
+/**
+ * Check if a pattern contains top-level braces (not nested in brackets).
+ */
+function containsTopLevelBraces(pattern) {
+    let inBracket = false;
+    let braceDepth = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : '';
+        // Skip escaped characters
+        if (prevChar === '\\')
+            continue;
+        if (char === '[' && !inBracket) {
+            inBracket = true;
+        }
+        else if (char === ']' && inBracket) {
+            inBracket = false;
+        }
+        else if (char === '{' && !inBracket) {
+            braceDepth++;
+        }
+        else if (char === '}' && !inBracket && braceDepth > 0) {
+            braceDepth--;
+        }
+    }
+    // Check again for actual braces
+    braceDepth = 0;
+    inBracket = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : '';
+        if (prevChar === '\\')
+            continue;
+        if (char === '[' && !inBracket) {
+            inBracket = true;
+        }
+        else if (char === ']' && inBracket) {
+            inBracket = false;
+        }
+        else if (char === '{' && !inBracket) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Expand braces one level (non-recursive, nested braces are an error).
+ */
+function expandBracesOnce(pattern, state) {
+    // Find the first top-level brace
+    let inBracket = false;
+    let braceStart = -1;
+    let braceEnd = -1;
+    let braceDepth = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : '';
+        if (prevChar === '\\')
+            continue;
+        if (char === '[' && !inBracket) {
+            inBracket = true;
+        }
+        else if (char === ']' && inBracket) {
+            inBracket = false;
+        }
+        else if (char === '{' && !inBracket) {
+            if (braceDepth === 0) {
+                braceStart = i;
+            }
+            braceDepth++;
+            // Check for nested braces
+            if (braceDepth > 1) {
+                state.errors.push({
+                    code: 'NESTED_BRACES',
+                    message: 'Nested braces are not allowed',
+                    position: i,
+                    length: 1,
+                });
+                // Continue parsing as if it weren't nested
+            }
+        }
+        else if (char === '}' && !inBracket) {
+            if (braceDepth > 0) {
+                braceDepth--;
+                if (braceDepth === 0) {
+                    braceEnd = i;
+                    break;
+                }
+            }
+        }
+    }
+    if (braceStart === -1) {
+        return [pattern];
+    }
+    if (braceEnd === -1) {
+        state.errors.push({
+            code: 'UNCLOSED_BRACE',
+            message: 'Unclosed brace in pattern',
+            position: braceStart,
+            length: 1,
+        });
+        return [pattern];
+    }
+    const prefix = pattern.slice(0, braceStart);
+    const braceContent = pattern.slice(braceStart + 1, braceEnd);
+    const suffix = pattern.slice(braceEnd + 1);
+    // Split brace content by commas (not inside nested structures)
+    const alternatives = splitByComma(braceContent);
+    // Check for numeric range like {1..10}
+    if (alternatives.length === 1 && alternatives[0].includes('..')) {
+        const rangeMatch = /^(-?\d+)\.\.(-?\d+)$/.exec(alternatives[0]);
+        if (rangeMatch) {
+            const start = parseInt(rangeMatch[1], 10);
+            const end = parseInt(rangeMatch[2], 10);
+            const step = start <= end ? 1 : -1;
+            const count = Math.abs(end - start) + 1;
+            if (count > 50) {
+                state.errors.push({
+                    code: 'EXPANSION_LIMIT',
+                    message: `Numeric range {${start}..${end}} exceeds limit of 50 elements`,
+                    position: braceStart,
+                    length: braceEnd - braceStart + 1,
+                });
+                // Truncate to 50
+                const truncated = [];
+                for (let i = 0; i < 50; i++) {
+                    truncated.push(String(start + i * step));
+                }
+                return expandBracesOnce(truncated.map((n) => prefix + n + suffix).join('|SPLIT|'), state).flatMap((p) => p.split('|SPLIT|'));
+            }
+            const expanded = [];
+            for (let n = start; step > 0 ? n <= end : n >= end; n += step) {
+                expanded.push(prefix + n + suffix);
+            }
+            // Recursively expand if more braces in suffix
+            if (containsTopLevelBraces(suffix)) {
+                return expanded.flatMap((p) => expandBracesOnce(p, state));
+            }
+            return expanded;
+        }
+    }
+    // Standard brace expansion
+    const expanded = alternatives.map((alt) => prefix + alt + suffix);
+    // Recursively expand if more braces
+    return expanded.flatMap((p) => {
+        if (containsTopLevelBraces(p)) {
+            return expandBracesOnce(p, state);
+        }
+        return [p];
+    });
+}
+/**
+ * Split a string by top-level commas.
+ */
+function splitByComma(content) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    let inBracket = false;
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        const prevChar = i > 0 ? content[i - 1] : '';
+        if (prevChar === '\\') {
+            current += char;
+            continue;
+        }
+        if (char === '[' && !inBracket) {
+            inBracket = true;
+            current += char;
+        }
+        else if (char === ']' && inBracket) {
+            inBracket = false;
+            current += char;
+        }
+        else if (char === '{' && !inBracket) {
+            depth++;
+            current += char;
+        }
+        else if (char === '}' && !inBracket && depth > 0) {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0 && !inBracket) {
+            parts.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Parse a segment sequence (path split by /).
+ */
+function parseSegmentSequence(pattern, state) {
+    // Remove leading / for absolute paths (we track absoluteness separately)
+    let toParse = pattern;
+    if (toParse.startsWith('/')) {
+        toParse = toParse.slice(1);
+    }
+    else if (toParse.startsWith('~/')) {
+        toParse = toParse.slice(2);
+    }
+    else if (toParse === '~') {
+        toParse = '';
+    }
+    if (toParse === '') {
+        return { type: 'sequence', segments: [] };
+    }
+    // Split by / but not inside brackets
+    const segmentStrings = splitBySlash(toParse);
+    const segments = segmentStrings.map((seg) => parseSegment(seg, state));
+    return { type: 'sequence', segments };
+}
+/**
+ * Split pattern by forward slashes (not inside brackets).
+ */
+function splitBySlash(pattern) {
+    const parts = [];
+    let current = '';
+    let inBracket = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : '';
+        if (prevChar === '\\') {
+            current += char;
+            continue;
+        }
+        if (char === '[' && !inBracket) {
+            inBracket = true;
+            current += char;
+        }
+        else if (char === ']' && inBracket) {
+            inBracket = false;
+            current += char;
+        }
+        else if (char === '/' && !inBracket) {
+            if (current !== '') {
+                parts.push(current);
+            }
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current !== '') {
+        parts.push(current);
+    }
+    return parts;
+}
+/**
+ * Check if a segment contains unescaped special characters.
+ */
+function hasUnescapedSpecial(segment, chars) {
+    for (let i = 0; i < segment.length; i++) {
+        const char = segment[i];
+        // Skip escaped characters
+        if (char === '\\' && i + 1 < segment.length) {
+            i++; // Skip next character
+            continue;
+        }
+        if (chars.includes(char)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Parse a single segment string into a Segment node.
+ */
+function parseSegment(segment, state) {
+    // Check for globstar
+    if (segment === '**') {
+        return { type: 'globstar' };
+    }
+    // Check for invalid globstar usage (unescaped **)
+    if (hasUnescapedSpecial(segment, '*') && segment !== '**') {
+        // Check if there's an actual ** sequence (not escaped)
+        for (let i = 0; i < segment.length - 1; i++) {
+            if (segment[i] === '\\') {
+                i++; // Skip escaped char
+                continue;
+            }
+            if (segment[i] === '*' && segment[i + 1] === '*') {
+                state.errors.push({
+                    code: 'INVALID_GLOBSTAR',
+                    message: '** must be a complete path segment, not part of a larger pattern',
+                    position: state.source.indexOf(segment),
+                    length: segment.length,
+                });
+                break;
+            }
+        }
+    }
+    // Analyze segment content - check for UNESCAPED special chars
+    const hasWildcard = hasUnescapedSpecial(segment, '*?');
+    const hasBracket = hasUnescapedSpecial(segment, '[');
+    // Pure literal (no unescaped wildcards or brackets)
+    if (!hasWildcard && !hasBracket) {
+        return {
+            type: 'literal',
+            value: unescapeSegment(segment),
+        };
+    }
+    // Parse into parts
+    const parts = parseSegmentParts(segment, state);
+    // If only wildcards (no charclass), use WildcardSegment
+    if (!hasBracket) {
+        const wildcardParts = parts.map((p) => {
+            if (p.type === 'literal')
+                return { type: 'literal', value: p.value };
+            if (p.type === 'star')
+                return { type: 'star' };
+            if (p.type === 'question')
+                return { type: 'question' };
+            // Should not happen for non-bracket segments
+            throw new Error(`Unexpected part type: ${p.type}`);
+        });
+        return {
+            type: 'wildcard',
+            pattern: segment,
+            parts: wildcardParts,
+        };
+    }
+    // Has character classes - use CompositeSegment
+    return {
+        type: 'composite',
+        parts,
+    };
+}
+/**
+ * Parse segment into component parts (literals, wildcards, charclasses).
+ */
+function parseSegmentParts(segment, state) {
+    const parts = [];
+    let i = 0;
+    let literalBuffer = '';
+    const flushLiteral = () => {
+        if (literalBuffer !== '') {
+            parts.push({ type: 'literal', value: literalBuffer });
+            literalBuffer = '';
+        }
+    };
+    while (i < segment.length) {
+        const char = segment[i];
+        // Handle escapes
+        if (char === '\\' && i + 1 < segment.length) {
+            literalBuffer += segment[i + 1];
+            i += 2;
+            continue;
+        }
+        if (char === '*') {
+            flushLiteral();
+            parts.push({ type: 'star' });
+            i++;
+        }
+        else if (char === '?') {
+            flushLiteral();
+            parts.push({ type: 'question' });
+            i++;
+        }
+        else if (char === '[') {
+            flushLiteral();
+            const { charclass, endIndex } = parseCharClass(segment, i, state);
+            parts.push({ type: 'charclass', spec: charclass });
+            i = endIndex;
+        }
+        else {
+            literalBuffer += char;
+            i++;
+        }
+    }
+    flushLiteral();
+    return parts;
+}
+/**
+ * Parse a character class [abc] or [a-z] or [!...].
+ */
+function parseCharClass(segment, startIndex, state) {
+    let i = startIndex + 1; // Skip opening [
+    let negated = false;
+    const ranges = [];
+    let chars = '';
+    // Check for negation
+    if (i < segment.length && (segment[i] === '!' || segment[i] === '^')) {
+        negated = true;
+        i++;
+    }
+    // Handle ] as first char (literal)
+    if (i < segment.length && segment[i] === ']') {
+        chars += ']';
+        i++;
+    }
+    while (i < segment.length) {
+        const char = segment[i];
+        if (char === ']') {
+            // End of character class
+            if (chars === '' && ranges.length === 0) {
+                state.errors.push({
+                    code: 'EMPTY_CHARCLASS',
+                    message: 'Empty character class',
+                    position: startIndex,
+                    length: i - startIndex + 1,
+                });
+            }
+            return {
+                charclass: { type: 'charclass', negated, ranges, chars },
+                endIndex: i + 1,
+            };
+        }
+        if (char === '\\' && i + 1 < segment.length) {
+            // Escaped character
+            chars += segment[i + 1];
+            i += 2;
+            continue;
+        }
+        // Check for range
+        if (i + 2 < segment.length && segment[i + 1] === '-' && segment[i + 2] !== ']') {
+            const start = char;
+            const end = segment[i + 2];
+            // Validate range
+            if (start.charCodeAt(0) > end.charCodeAt(0)) {
+                state.errors.push({
+                    code: 'INVALID_RANGE',
+                    message: `Invalid range [${start}-${end}]: start > end`,
+                    position: startIndex + i,
+                    length: 3,
+                });
+            }
+            ranges.push({ start, end });
+            i += 3;
+        }
+        else {
+            chars += char;
+            i++;
+        }
+    }
+    // Unclosed bracket
+    state.errors.push({
+        code: 'UNCLOSED_BRACKET',
+        message: 'Unclosed character class',
+        position: startIndex,
+        length: segment.length - startIndex,
+    });
+    return {
+        charclass: { type: 'charclass', negated, ranges, chars },
+        endIndex: segment.length,
+    };
+}
+/**
+ * Unescape a literal segment (remove backslashes).
+ */
+function unescapeSegment(segment) {
+    let result = '';
+    let i = 0;
+    while (i < segment.length) {
+        if (segment[i] === '\\' && i + 1 < segment.length) {
+            result += segment[i + 1];
+            i += 2;
+        }
+        else {
+            result += segment[i];
+            i++;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=parser.js.map