@bcts/envelope-pattern 1.0.0-alpha.16 → 1.0.0-alpha.18

package/src/pattern/matcher.ts

@@ -88,14 +88,23 @@ export function compileAsAtomic(
 }
 
 // ============================================================================
-// Pattern Match Registry
+// Pattern Dispatch Registry
 // ============================================================================
 
 /**
- * Registry for pattern matching function to break circular dependencies.
- * This allows meta patterns to match child patterns without importing from index.ts.
+ * Registry for pattern dispatch functions to break circular dependencies.
+ * This allows meta patterns to dispatch to child patterns without importing from index.ts.
  */
 let patternMatchFn: ((pattern: Pattern, haystack: Envelope) => boolean) | undefined;
+let patternPathsWithCapturesFn:
+  | ((pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>])
+  | undefined;
+let patternPathsFn: ((pattern: Pattern, haystack: Envelope) => Path[]) | undefined;
+let patternCompileFn:
+  | ((pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void)
+  | undefined;
+let patternIsComplexFn: ((pattern: Pattern) => boolean) | undefined;
+let patternToStringFn: ((pattern: Pattern) => string) | undefined;
 
 /**
  * Registers the pattern match function.
@@ -107,6 +116,24 @@ export function registerPatternMatchFn(
   patternMatchFn = fn;
 }
 
+/**
+ * Registers all pattern dispatch functions.
+ * Called from index.ts after all patterns are defined.
+ */
+export function registerPatternDispatchFns(fns: {
+  pathsWithCaptures: (pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>];
+  paths: (pattern: Pattern, haystack: Envelope) => Path[];
+  compile: (pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void;
+  isComplex: (pattern: Pattern) => boolean;
+  toString: (pattern: Pattern) => string;
+}): void {
+  patternPathsWithCapturesFn = fns.pathsWithCaptures;
+  patternPathsFn = fns.paths;
+  patternCompileFn = fns.compile;
+  patternIsComplexFn = fns.isComplex;
+  patternToStringFn = fns.toString;
+}
+
 /**
  * Match a pattern against an envelope using the registered match function.
  * Used by meta patterns to match child patterns.
@@ -117,3 +144,61 @@ export function matchPattern(pattern: Pattern, haystack: Envelope): boolean {
   }
   return patternMatchFn(pattern, haystack);
 }
+
+/**
+ * Dispatch pathsWithCaptures on a Pattern.
+ */
+export function dispatchPathsWithCaptures(
+  pattern: Pattern,
+  haystack: Envelope,
+): [Path[], Map<string, Path[]>] {
+  if (patternPathsWithCapturesFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternPathsWithCapturesFn(pattern, haystack);
+}
+
+/**
+ * Dispatch paths on a Pattern.
+ */
+export function dispatchPaths(pattern: Pattern, haystack: Envelope): Path[] {
+  if (patternPathsFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternPathsFn(pattern, haystack);
+}
+
+/**
+ * Dispatch compile on a Pattern.
+ */
+export function dispatchCompile(
+  pattern: Pattern,
+  code: Instr[],
+  literals: Pattern[],
+  captures: string[],
+): void {
+  if (patternCompileFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  patternCompileFn(pattern, code, literals, captures);
+}
+
+/**
+ * Dispatch isComplex on a Pattern.
+ */
+export function dispatchIsComplex(pattern: Pattern): boolean {
+  if (patternIsComplexFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternIsComplexFn(pattern);
+}
+
+/**
+ * Dispatch toString on a Pattern.
+ */
+export function dispatchPatternToString(pattern: Pattern): string {
+  if (patternToStringFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternToStringFn(pattern);
+}

package/src/pattern/meta/and-pattern.ts

@@ -8,9 +8,15 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { type Matcher, matchPattern } from "../matcher";
+import {
+  matchPattern,
+  dispatchCompile,
+  dispatchIsComplex,
+  dispatchPatternToString,
+} from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaAndPattern: ((pattern: AndPattern) => Pattern) | undefined;
@@ -25,10 +31,10 @@ export function registerAndPatternFactory(factory: (pattern: AndPattern) => Patt
  * Corresponds to the Rust `AndPattern` struct in and_pattern.rs
  */
 export class AndPattern implements Matcher {
-  readonly #patterns: Pattern[];
+  private readonly _patterns: Pattern[];
 
   private constructor(patterns: Pattern[]) {
-    this.#patterns = patterns;
+    this._patterns = patterns;
   }
 
   /**
@@ -42,11 +48,11 @@ export class AndPattern implements Matcher {
    * Gets the patterns.
    */
   patterns(): Pattern[] {
-    return this.#patterns;
+    return this._patterns;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const allMatch = this.#patterns.every((pattern) => matchPattern(pattern, haystack));
+    const allMatch = this._patterns.every((pattern) => matchPattern(pattern, haystack));
 
     const paths = allMatch ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];
@@ -62,35 +68,30 @@ export class AndPattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     // Each pattern must match at this position
-    for (const pattern of this.#patterns) {
-      const matcher = pattern as unknown as Matcher;
-      matcher.compile(code, literals, captures);
+    for (const pattern of this._patterns) {
+      dispatchCompile(pattern, code, literals, captures);
     }
   }
 
   isComplex(): boolean {
     // The pattern is complex if it contains more than one pattern, or if
     // the one pattern is complex itself.
-    return (
-      this.#patterns.length > 1 || this.#patterns.some((p) => (p as unknown as Matcher).isComplex())
-    );
+    return this._patterns.length > 1 || this._patterns.some((p) => dispatchIsComplex(p));
   }
 
   toString(): string {
-    return this.#patterns
-      .map((p) => (p as unknown as { toString(): string }).toString())
-      .join(" & ");
+    return this._patterns.map((p) => dispatchPatternToString(p)).join(" & ");
   }
 
   /**
    * Equality comparison.
    */
   equals(other: AndPattern): boolean {
-    if (this.#patterns.length !== other.#patterns.length) {
+    if (this._patterns.length !== other._patterns.length) {
       return false;
     }
-    for (let i = 0; i < this.#patterns.length; i++) {
-      if (this.#patterns[i] !== other.#patterns[i]) {
+    for (let i = 0; i < this._patterns.length; i++) {
+      if (this._patterns[i] !== other._patterns[i]) {
         return false;
       }
     }
@@ -101,6 +102,6 @@ export class AndPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#patterns.length;
+    return this._patterns.length;
   }
 }

package/src/pattern/meta/capture-pattern.ts

@@ -8,9 +8,10 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { dispatchPathsWithCaptures, dispatchCompile, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaCapturePattern: ((pattern: CapturePattern) => Pattern) | undefined;
@@ -25,12 +26,12 @@ export function registerCapturePatternFactory(factory: (pattern: CapturePattern)
  * Corresponds to the Rust `CapturePattern` struct in capture_pattern.rs
  */
 export class CapturePattern implements Matcher {
-  readonly #name: string;
-  readonly #pattern: Pattern;
+  private readonly _name: string;
+  private readonly _pattern: Pattern;
 
   private constructor(name: string, pattern: Pattern) {
-    this.#name = name;
-    this.#pattern = pattern;
+    this._name = name;
+    this._pattern = pattern;
   }
 
   /**
@@ -44,23 +45,22 @@ export class CapturePattern implements Matcher {
    * Gets the name of the capture.
    */
   name(): string {
-    return this.#name;
+    return this._name;
   }
 
   /**
    * Gets the inner pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const matcher = this.#pattern as unknown as Matcher;
-    const [paths, caps] = matcher.pathsWithCaptures(haystack);
+    const [paths, caps] = dispatchPathsWithCaptures(this._pattern, haystack);
 
     if (paths.length > 0) {
-      const existing = caps.get(this.#name) ?? [];
-      caps.set(this.#name, [...existing, ...paths]);
+      const existing = caps.get(this._name) ?? [];
+      caps.set(this._name, [...existing, ...paths]);
     }
 
     return [paths, caps];
@@ -76,10 +76,9 @@ export class CapturePattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     const id = captures.length;
-    captures.push(this.#name);
+    captures.push(this._name);
     code.push({ type: "CaptureStart", captureIndex: id });
-    const matcher = this.#pattern as unknown as Matcher;
-    matcher.compile(code, literals, captures);
+    dispatchCompile(this._pattern, code, literals, captures);
     code.push({ type: "CaptureEnd", captureIndex: id });
   }
 
@@ -88,14 +87,14 @@ export class CapturePattern implements Matcher {
   }
 
   toString(): string {
-    return `@${this.#name}(${(this.#pattern as unknown as { toString(): string }).toString()})`;
+    return `@${this._name}(${dispatchPatternToString(this._pattern)})`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: CapturePattern): boolean {
-    return this.#name === other.#name && this.#pattern === other.#pattern;
+    return this._name === other._name && this._pattern === other._pattern;
   }
 
   /**
@@ -103,7 +102,7 @@ export class CapturePattern implements Matcher {
    */
   hashCode(): number {
     let hash = 0;
-    for (const char of this.#name) {
+    for (const char of this._name) {
       hash = (hash * 31 + char.charCodeAt(0)) | 0;
     }
     return hash;

package/src/pattern/meta/group-pattern.ts

@@ -9,9 +9,10 @@
 import type { Envelope } from "@bcts/envelope";
 import { Quantifier } from "@bcts/dcbor-pattern";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { matchPattern, dispatchPathsWithCaptures, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaGroupPattern: ((pattern: GroupPattern) => Pattern) | undefined;
@@ -26,12 +27,12 @@ export function registerGroupPatternFactory(factory: (pattern: GroupPattern) =>
  * Corresponds to the Rust `GroupPattern` struct in repeat_pattern.rs
  */
 export class GroupPattern implements Matcher {
-  readonly #pattern: Pattern;
-  readonly #quantifier: Quantifier;
+  private readonly _pattern: Pattern;
+  private readonly _quantifier: Quantifier;
 
   private constructor(pattern: Pattern, quantifier: Quantifier) {
-    this.#pattern = pattern;
-    this.#quantifier = quantifier;
+    this._pattern = pattern;
+    this._quantifier = quantifier;
   }
 
   /**
@@ -52,17 +53,21 @@ export class GroupPattern implements Matcher {
    * Gets the sub-pattern of this group pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the quantifier of this group pattern.
    */
   quantifier(): Quantifier {
-    return this.#quantifier;
+    return this._quantifier;
   }
 
-  pathsWithCaptures(_haystack: Envelope): [Path[], Map<string, Path[]>] {
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // For simple grouping (exactly 1), delegate to the inner pattern
+    if (this._quantifier.min() === 1 && this._quantifier.max() === 1) {
+      return dispatchPathsWithCaptures(this._pattern, haystack);
+    }
     throw new Error(
       "GroupPattern does not support pathsWithCaptures directly; use compile instead",
     );
@@ -73,15 +78,13 @@ export class GroupPattern implements Matcher {
   }
 
   matches(haystack: Envelope): boolean {
-    // GroupPattern needs VM execution
-    const matcher = this.#pattern as unknown as Matcher;
-    return matcher.matches(haystack);
+    return matchPattern(this._pattern, haystack);
   }
 
   compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
     const idx = literals.length;
-    literals.push(this.#pattern);
-    code.push({ type: "Repeat", patternIndex: idx, quantifier: this.#quantifier });
+    literals.push(this._pattern);
+    code.push({ type: "Repeat", patternIndex: idx, quantifier: this._quantifier });
   }
 
   isComplex(): boolean {
@@ -89,15 +92,15 @@ export class GroupPattern implements Matcher {
   }
 
   toString(): string {
-    const formattedRange = this.#quantifier.toString();
-    return `(${(this.#pattern as unknown as { toString(): string }).toString()})${formattedRange}`;
+    const formattedRange = this._quantifier.toString();
+    return `(${dispatchPatternToString(this._pattern)})${formattedRange}`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: GroupPattern): boolean {
-    return this.#pattern === other.#pattern && this.#quantifier.equals(other.#quantifier);
+    return this._pattern === other._pattern && this._quantifier.equals(other._quantifier);
   }
 
   /**
@@ -105,6 +108,6 @@ export class GroupPattern implements Matcher {
    */
   hashCode(): number {
     // Simple hash based on quantifier min/max
-    return this.#quantifier.min() * 31 + (this.#quantifier.max() ?? 0);
+    return this._quantifier.min() * 31 + (this._quantifier.max() ?? 0);
   }
 }

package/src/pattern/meta/not-pattern.ts

@@ -8,9 +8,10 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { type Matcher, matchPattern } from "../matcher";
+import { matchPattern, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaNotPattern: ((pattern: NotPattern) => Pattern) | undefined;
@@ -25,10 +26,10 @@ export function registerNotPatternFactory(factory: (pattern: NotPattern) => Patt
  * Corresponds to the Rust `NotPattern` struct in not_pattern.rs
  */
 export class NotPattern implements Matcher {
-  readonly #pattern: Pattern;
+  private readonly _pattern: Pattern;
 
   private constructor(pattern: Pattern) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -42,12 +43,12 @@ export class NotPattern implements Matcher {
    * Gets the inner pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     // If the inner pattern doesn't match, then we return the current envelope as a match
-    const paths = !matchPattern(this.#pattern, haystack) ? [[haystack]] : [];
+    const paths = !matchPattern(this._pattern, haystack) ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];
   }
 
@@ -62,7 +63,7 @@ export class NotPattern implements Matcher {
   compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
     // NOT = check that pattern doesn't match
     const idx = literals.length;
-    literals.push(this.#pattern);
+    literals.push(this._pattern);
     code.push({ type: "NotMatch", patternIndex: idx });
   }
 
@@ -71,14 +72,14 @@ export class NotPattern implements Matcher {
   }
 
   toString(): string {
-    return `!${(this.#pattern as unknown as { toString(): string }).toString()}`;
+    return `!${dispatchPatternToString(this._pattern)}`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: NotPattern): boolean {
-    return this.#pattern === other.#pattern;
+    return this._pattern === other._pattern;
   }
 
   /**

package/src/pattern/meta/or-pattern.ts

@@ -8,9 +8,15 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { type Matcher, matchPattern } from "../matcher";
+import {
+  dispatchPathsWithCaptures,
+  dispatchCompile,
+  dispatchIsComplex,
+  dispatchPatternToString,
+} from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaOrPattern: ((pattern: OrPattern) => Pattern) | undefined;
@@ -25,10 +31,10 @@ export function registerOrPatternFactory(factory: (pattern: OrPattern) => Patter
  * Corresponds to the Rust `OrPattern` struct in or_pattern.rs
  */
 export class OrPattern implements Matcher {
-  readonly #patterns: Pattern[];
+  private readonly _patterns: Pattern[];
 
   private constructor(patterns: Pattern[]) {
-    this.#patterns = patterns;
+    this._patterns = patterns;
   }
 
   /**
@@ -42,14 +48,18 @@ export class OrPattern implements Matcher {
    * Gets the patterns.
    */
   patterns(): Pattern[] {
-    return this.#patterns;
+    return this._patterns;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const anyMatch = this.#patterns.some((pattern) => matchPattern(pattern, haystack));
-
-    const paths = anyMatch ? [[haystack]] : [];
-    return [paths, new Map<string, Path[]>()];
+    // Try each pattern and return paths+captures from the first match
+    for (const pattern of this._patterns) {
+      const [paths, captures] = dispatchPathsWithCaptures(pattern, haystack);
+      if (paths.length > 0) {
+        return [paths, captures];
+      }
+    }
+    return [[], new Map<string, Path[]>()];
   }
 
   paths(haystack: Envelope): Path[] {
@@ -61,7 +71,7 @@ export class OrPattern implements Matcher {
   }
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
-    if (this.#patterns.length === 0) {
+    if (this._patterns.length === 0) {
       return;
     }
 
@@ -69,7 +79,7 @@ export class OrPattern implements Matcher {
     const splits: number[] = [];
 
     // Generate splits for all but the last pattern
-    for (let i = 0; i < this.#patterns.length - 1; i++) {
+    for (let i = 0; i < this._patterns.length - 1; i++) {
       splits.push(code.length);
       code.push({ type: "Split", a: 0, b: 0 }); // Placeholder
     }
@@ -78,13 +88,12 @@ export class OrPattern implements Matcher {
     const jumps: number[] = [];
 
     // Now fill in the actual split targets
-    for (let i = 0; i < this.#patterns.length; i++) {
+    for (let i = 0; i < this._patterns.length; i++) {
       const patternStart = code.length;
 
       // Compile this pattern
-      const pattern = this.#patterns[i];
-      const matcher = pattern as unknown as Matcher;
-      matcher.compile(code, literals, captures);
+      const pattern = this._patterns[i];
+      dispatchCompile(pattern, code, literals, captures);
 
       // This pattern will jump to the end if it matches
       const jumpPastAll = code.length;
@@ -92,7 +101,7 @@ export class OrPattern implements Matcher {
       jumps.push(jumpPastAll);
 
       // If there's a next pattern, update the split to point here
-      if (i < this.#patterns.length - 1) {
+      if (i < this._patterns.length - 1) {
         const nextPattern = code.length;
         code[splits[i]] = { type: "Split", a: patternStart, b: nextPattern };
       }
@@ -108,26 +117,22 @@ export class OrPattern implements Matcher {
   isComplex(): boolean {
     // The pattern is complex if it contains more than one pattern, or if
     // the one pattern is complex itself.
-    return (
-      this.#patterns.length > 1 || this.#patterns.some((p) => (p as unknown as Matcher).isComplex())
-    );
+    return this._patterns.length > 1 || this._patterns.some((p) => dispatchIsComplex(p));
   }
 
   toString(): string {
-    return this.#patterns
-      .map((p) => (p as unknown as { toString(): string }).toString())
-      .join(" | ");
+    return this._patterns.map((p) => dispatchPatternToString(p)).join(" | ");
   }
 
   /**
    * Equality comparison.
    */
   equals(other: OrPattern): boolean {
-    if (this.#patterns.length !== other.#patterns.length) {
+    if (this._patterns.length !== other._patterns.length) {
       return false;
     }
-    for (let i = 0; i < this.#patterns.length; i++) {
-      if (this.#patterns[i] !== other.#patterns[i]) {
+    for (let i = 0; i < this._patterns.length; i++) {
+      if (this._patterns[i] !== other._patterns[i]) {
         return false;
       }
     }
@@ -138,6 +143,6 @@ export class OrPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#patterns.length;
+    return this._patterns.length;
   }
 }