@bcts/envelope-pattern 1.0.0-alpha.12

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

@@ -0,0 +1,146 @@
+/**
+ * @bcts/envelope-pattern - Traverse pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust traverse_pattern.rs
+ *
+ * @module envelope-pattern/pattern/meta/traverse-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory (used for late binding)
+export let createMetaTraversePattern: ((pattern: TraversePattern) => Pattern) | undefined;
+
+export function registerTraversePatternFactory(
+  factory: (pattern: TraversePattern) => Pattern,
+): void {
+  createMetaTraversePattern = factory;
+}
+
+/**
+ * A pattern that matches a traversal order of patterns.
+ *
+ * Corresponds to the Rust `TraversePattern` struct in traverse_pattern.rs
+ */
+export class TraversePattern implements Matcher {
+  readonly #first: Pattern;
+  readonly #rest: TraversePattern | undefined;
+
+  private constructor(first: Pattern, rest: TraversePattern | undefined) {
+    this.#first = first;
+    this.#rest = rest;
+  }
+
+  /**
+   * Creates a new TraversePattern with the given patterns.
+   */
+  static new(patterns: Pattern[]): TraversePattern {
+    if (patterns.length === 0) {
+      throw new Error("TraversePattern requires at least one pattern");
+    }
+
+    const firstPat = patterns[0];
+    const restPatterns = patterns.slice(1);
+    const rest = restPatterns.length === 0 ? undefined : TraversePattern.new(restPatterns);
+    return new TraversePattern(firstPat, rest);
+  }
+
+  /**
+   * Gets all patterns in this traversal.
+   */
+  patterns(): Pattern[] {
+    const result: Pattern[] = [this.#first];
+    if (this.#rest !== undefined) {
+      result.push(...this.#rest.patterns());
+    }
+    return result;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const firstMatcher = this.#first as unknown as Matcher;
+    const headPaths = firstMatcher.paths(haystack);
+
+    // If there's no further traversal, return head paths
+    if (this.#rest === undefined) {
+      return [headPaths, new Map<string, Path[]>()];
+    }
+
+    const result: Path[] = [];
+    for (const path of headPaths) {
+      const lastEnv = path[path.length - 1];
+      if (lastEnv !== undefined) {
+        // Recursively match the rest of the traversal
+        const tailPaths = this.#rest.paths(lastEnv);
+        for (const tailPath of tailPaths) {
+          const combined = [...path, ...tailPath];
+          result.push(combined);
+        }
+      }
+    }
+
+    return [result, new Map<string, Path[]>()];
+  }
+
+  paths(haystack: Envelope): Path[] {
+    return this.pathsWithCaptures(haystack)[0];
+  }
+
+  matches(haystack: Envelope): boolean {
+    return this.paths(haystack).length > 0;
+  }
+
+  compile(code: Instr[], literals: Pattern[], captures: string[]): void {
+    // Compile the first pattern
+    const firstMatcher = this.#first as unknown as Matcher;
+    firstMatcher.compile(code, literals, captures);
+
+    if (this.#rest !== undefined) {
+      // Save the current path and switch to last envelope
+      code.push({ type: "ExtendTraversal" });
+      // Compile the rest of the traversal
+      this.#rest.compile(code, literals, captures);
+      // Combine the paths correctly
+      code.push({ type: "CombineTraversal" });
+    }
+  }
+
+  isComplex(): boolean {
+    // A traversal is complex if `first` is complex, or it has more than one pattern
+    const firstMatcher = this.#first as unknown as Matcher;
+    return firstMatcher.isComplex() || this.#rest !== undefined;
+  }
+
+  toString(): string {
+    return this.patterns()
+      .map((p) => (p as unknown as { toString(): string }).toString())
+      .join(" -> ");
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: TraversePattern): boolean {
+    const thisPatterns = this.patterns();
+    const otherPatterns = other.patterns();
+    if (thisPatterns.length !== otherPatterns.length) {
+      return false;
+    }
+    for (let i = 0; i < thisPatterns.length; i++) {
+      if (thisPatterns[i] !== otherPatterns[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return this.patterns().length;
+  }
+}

package/src/pattern/structure/assertions-pattern.ts

@@ -0,0 +1,244 @@
+/**
+ * @bcts/envelope-pattern - Assertions pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust assertions_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/assertions-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory
+let createStructureAssertionsPattern: ((pattern: AssertionsPattern) => Pattern) | undefined;
+
+export function registerAssertionsPatternFactory(
+  factory: (pattern: AssertionsPattern) => Pattern,
+): void {
+  createStructureAssertionsPattern = factory;
+}
+
+/**
+ * Pattern type for assertions pattern matching.
+ *
+ * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs
+ */
+export type AssertionsPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "WithPredicate"; readonly pattern: Pattern }
+  | { readonly type: "WithObject"; readonly pattern: Pattern }
+  | {
+      readonly type: "WithBoth";
+      readonly predicatePattern: Pattern;
+      readonly objectPattern: Pattern;
+    };
+
+/**
+ * Pattern for matching assertions in envelopes.
+ *
+ * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs
+ */
+export class AssertionsPattern implements Matcher {
+  readonly #pattern: AssertionsPatternType;
+
+  private constructor(pattern: AssertionsPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new AssertionsPattern that matches any assertion.
+   */
+  static any(): AssertionsPattern {
+    return new AssertionsPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new AssertionsPattern that matches assertions with predicates
+   * that match a specific pattern.
+   */
+  static withPredicate(pattern: Pattern): AssertionsPattern {
+    return new AssertionsPattern({ type: "WithPredicate", pattern });
+  }
+
+  /**
+   * Creates a new AssertionsPattern that matches assertions with objects
+   * that match a specific pattern.
+   */
+  static withObject(pattern: Pattern): AssertionsPattern {
+    return new AssertionsPattern({ type: "WithObject", pattern });
+  }
+
+  /**
+   * Creates a new AssertionsPattern that matches assertions with both
+   * predicate and object patterns.
+   */
+  static withBoth(predicatePattern: Pattern, objectPattern: Pattern): AssertionsPattern {
+    return new AssertionsPattern({ type: "WithBoth", predicatePattern, objectPattern });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): AssertionsPatternType {
+    return this.#pattern;
+  }
+
+  /**
+   * Gets the predicate pattern if this has one, undefined otherwise.
+   */
+  predicatePattern(): Pattern | undefined {
+    if (this.#pattern.type === "WithPredicate") {
+      return this.#pattern.pattern;
+    }
+    if (this.#pattern.type === "WithBoth") {
+      return this.#pattern.predicatePattern;
+    }
+    return undefined;
+  }
+
+  /**
+   * Gets the object pattern if this has one, undefined otherwise.
+   */
+  objectPattern(): Pattern | undefined {
+    if (this.#pattern.type === "WithObject") {
+      return this.#pattern.pattern;
+    }
+    if (this.#pattern.type === "WithBoth") {
+      return this.#pattern.objectPattern;
+    }
+    return undefined;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const paths: Path[] = [];
+
+    for (const assertion of haystack.assertions()) {
+      switch (this.#pattern.type) {
+        case "Any":
+          paths.push([assertion]);
+          break;
+        case "WithPredicate": {
+          const predicate = assertion.asPredicate?.();
+          if (predicate !== undefined) {
+            const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+            if (innerMatcher.matches(predicate)) {
+              paths.push([assertion]);
+            }
+          }
+          break;
+        }
+        case "WithObject": {
+          const object = assertion.asObject?.();
+          if (object !== undefined) {
+            const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+            if (innerMatcher.matches(object)) {
+              paths.push([assertion]);
+            }
+          }
+          break;
+        }
+        case "WithBoth": {
+          const predicate = assertion.asPredicate?.();
+          const object = assertion.asObject?.();
+          if (predicate !== undefined && object !== undefined) {
+            const predMatcher = this.#pattern.predicatePattern as unknown as Matcher;
+            const objMatcher = this.#pattern.objectPattern as unknown as Matcher;
+            if (predMatcher.matches(predicate) && objMatcher.matches(object)) {
+              paths.push([assertion]);
+            }
+          }
+          break;
+        }
+      }
+    }
+
+    return [paths, new Map<string, Path[]>()];
+  }
+
+  paths(haystack: Envelope): Path[] {
+    return this.pathsWithCaptures(haystack)[0];
+  }
+
+  matches(haystack: Envelope): boolean {
+    return this.paths(haystack).length > 0;
+  }
+
+  compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
+    if (createStructureAssertionsPattern === undefined) {
+      throw new Error("AssertionsPattern factory not registered");
+    }
+    const idx = literals.length;
+    literals.push(createStructureAssertionsPattern(this));
+    code.push({ type: "MatchStructure", literalIndex: idx });
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "assert";
+      case "WithPredicate":
+        return `assertpred(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+      case "WithObject":
+        return `assertobj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+      case "WithBoth":
+        return `assert(${(this.#pattern.predicatePattern as unknown as { toString(): string }).toString()}, ${(this.#pattern.objectPattern as unknown as { toString(): string }).toString()})`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: AssertionsPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    switch (this.#pattern.type) {
+      case "Any":
+        return true;
+      case "WithPredicate":
+      case "WithObject": {
+        const thisPattern = (
+          this.#pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
+        ).pattern;
+        const otherPattern = (
+          other.#pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
+        ).pattern;
+        return thisPattern === otherPattern;
+      }
+      case "WithBoth": {
+        const otherBoth = other.#pattern as {
+          type: "WithBoth";
+          predicatePattern: Pattern;
+          objectPattern: Pattern;
+        };
+        return (
+          this.#pattern.predicatePattern === otherBoth.predicatePattern &&
+          this.#pattern.objectPattern === otherBoth.objectPattern
+        );
+      }
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "WithPredicate":
+        return 1;
+      case "WithObject":
+        return 2;
+      case "WithBoth":
+        return 3;
+    }
+  }
+}

package/src/pattern/structure/digest-pattern.ts

@@ -0,0 +1,225 @@
+/**
+ * @bcts/envelope-pattern - Digest pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust digest_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/digest-pattern
+ */
+
+import type { Envelope, Digest } from "@bcts/envelope";
+import { bytesToHex } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import { compileAsAtomic } from "../matcher";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory
+let createStructureDigestPattern: ((pattern: DigestPattern) => Pattern) | undefined;
+
+export function registerDigestPatternFactory(factory: (pattern: DigestPattern) => Pattern): void {
+  createStructureDigestPattern = factory;
+}
+
+/**
+ * Helper to convert bytes to Latin-1 string for regex matching.
+ */
+function bytesToLatin1(bytes: Uint8Array): string {
+  let result = "";
+  for (const byte of bytes) {
+    result += String.fromCharCode(byte);
+  }
+  return result;
+}
+
+/**
+ * Pattern type for digest pattern matching.
+ *
+ * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs
+ */
+export type DigestPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Digest"; readonly digest: Digest }
+  | { readonly type: "Prefix"; readonly prefix: Uint8Array }
+  | { readonly type: "BinaryRegex"; readonly regex: RegExp };
+
+/**
+ * Pattern for matching envelopes by their digest.
+ *
+ * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs
+ */
+export class DigestPattern implements Matcher {
+  readonly #pattern: DigestPatternType;
+
+  private constructor(pattern: DigestPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new DigestPattern that matches any digest.
+   */
+  static any(): DigestPattern {
+    return new DigestPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new DigestPattern that matches the exact digest.
+   */
+  static digest(digest: Digest): DigestPattern {
+    return new DigestPattern({ type: "Digest", digest });
+  }
+
+  /**
+   * Creates a new DigestPattern that matches the prefix of a digest.
+   */
+  static prefix(prefix: Uint8Array): DigestPattern {
+    return new DigestPattern({ type: "Prefix", prefix });
+  }
+
+  /**
+   * Creates a new DigestPattern that matches the binary regex for a digest.
+   */
+  static binaryRegex(regex: RegExp): DigestPattern {
+    return new DigestPattern({ type: "BinaryRegex", regex });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): DigestPatternType {
+    return this.#pattern;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const digest = haystack.digest();
+    const digestData = digest.data();
+    let isHit = false;
+
+    switch (this.#pattern.type) {
+      case "Any":
+        // Any digest matches - every envelope has a digest
+        isHit = true;
+        break;
+      case "Digest":
+        isHit = digest.equals(this.#pattern.digest);
+        break;
+      case "Prefix": {
+        const prefix = this.#pattern.prefix;
+        if (digestData.length >= prefix.length) {
+          isHit = true;
+          for (let i = 0; i < prefix.length; i++) {
+            if (digestData[i] !== prefix[i]) {
+              isHit = false;
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case "BinaryRegex": {
+        const latin1 = bytesToLatin1(digestData);
+        isHit = this.#pattern.regex.test(latin1);
+        break;
+      }
+    }
+
+    const paths = isHit ? [[haystack]] : [];
+    return [paths, new Map<string, Path[]>()];
+  }
+
+  paths(haystack: Envelope): Path[] {
+    return this.pathsWithCaptures(haystack)[0];
+  }
+
+  matches(haystack: Envelope): boolean {
+    return this.paths(haystack).length > 0;
+  }
+
+  compile(code: Instr[], literals: Pattern[], captures: string[]): void {
+    if (createStructureDigestPattern === undefined) {
+      throw new Error("DigestPattern factory not registered");
+    }
+    compileAsAtomic(createStructureDigestPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "digest";
+      case "Digest":
+        return `digest(${this.#pattern.digest.hex()})`;
+      case "Prefix":
+        return `digest(${bytesToHex(this.#pattern.prefix)})`;
+      case "BinaryRegex":
+        return `digest(/${this.#pattern.regex.source}/)`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: DigestPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    switch (this.#pattern.type) {
+      case "Any":
+        return true;
+      case "Digest":
+        return this.#pattern.digest.equals(
+          (other.#pattern as { type: "Digest"; digest: Digest }).digest,
+        );
+      case "Prefix": {
+        const thisPrefix = this.#pattern.prefix;
+        const otherPrefix = (other.#pattern as { type: "Prefix"; prefix: Uint8Array }).prefix;
+        if (thisPrefix.length !== otherPrefix.length) return false;
+        for (let i = 0; i < thisPrefix.length; i++) {
+          if (thisPrefix[i] !== otherPrefix[i]) return false;
+        }
+        return true;
+      }
+      case "BinaryRegex":
+        return (
+          this.#pattern.regex.source ===
+          (other.#pattern as { type: "BinaryRegex"; regex: RegExp }).regex.source
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "Digest": {
+        // Hash based on first few bytes of digest
+        const data = this.#pattern.digest.data().slice(0, 8);
+        let hash = 0;
+        for (const byte of data) {
+          hash = (hash * 31 + byte) | 0;
+        }
+        return hash;
+      }
+      case "Prefix": {
+        let hash = 0;
+        for (const byte of this.#pattern.prefix) {
+          hash = (hash * 31 + byte) | 0;
+        }
+        return hash;
+      }
+      case "BinaryRegex": {
+        let hash = 0;
+        for (const char of this.#pattern.regex.source) {
+          hash = (hash * 31 + char.charCodeAt(0)) | 0;
+        }
+        return hash;
+      }
+    }
+  }
+}