@bcts/envelope-pattern 1.0.0-alpha.12

package/src/pattern/leaf/array-pattern.ts

@@ -0,0 +1,273 @@
+/**
+ * @bcts/envelope-pattern - Array pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust array_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/array-pattern
+ */
+
+import { Envelope } from "@bcts/envelope";
+import { asCborArray, type Cbor } from "@bcts/dcbor";
+import {
+  type Pattern as DCBORPattern,
+  Interval,
+  patternPathsWithCaptures as dcborPatternPathsWithCaptures,
+  patternDisplay as dcborPatternDisplay,
+} from "@bcts/dcbor-pattern";
+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 createLeafArrayPattern: ((pattern: ArrayPattern) => Pattern) | undefined;
+
+export function registerArrayPatternFactory(factory: (pattern: ArrayPattern) => Pattern): void {
+  createLeafArrayPattern = factory;
+}
+
+/**
+ * Pattern for matching array values.
+ *
+ * Corresponds to the Rust `ArrayPattern` enum in array_pattern.rs
+ */
+export type ArrayPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Interval"; readonly interval: Interval }
+  | { readonly type: "DCBORPattern"; readonly pattern: DCBORPattern }
+  | { readonly type: "WithPatterns"; readonly patterns: Pattern[] };
+
+/**
+ * Pattern for matching array values in envelope leaf nodes.
+ *
+ * Corresponds to the Rust `ArrayPattern` struct in array_pattern.rs
+ */
+export class ArrayPattern implements Matcher {
+  readonly #pattern: ArrayPatternType;
+
+  private constructor(pattern: ArrayPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new ArrayPattern that matches any array.
+   */
+  static any(): ArrayPattern {
+    return new ArrayPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new ArrayPattern that matches arrays with a specific length.
+   */
+  static count(count: number): ArrayPattern {
+    return new ArrayPattern({
+      type: "Interval",
+      interval: Interval.exactly(count),
+    });
+  }
+
+  /**
+   * Creates a new ArrayPattern that matches arrays within a length range.
+   */
+  static interval(min: number, max?: number): ArrayPattern {
+    const interval = max !== undefined ? Interval.from(min, max) : Interval.atLeast(min);
+    return new ArrayPattern({ type: "Interval", interval });
+  }
+
+  /**
+   * Creates a new ArrayPattern from a dcbor-pattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORPattern): ArrayPattern {
+    return new ArrayPattern({ type: "DCBORPattern", pattern: dcborPattern });
+  }
+
+  /**
+   * Creates a new ArrayPattern with envelope patterns for element matching.
+   */
+  static withPatterns(patterns: Pattern[]): ArrayPattern {
+    return new ArrayPattern({ type: "WithPatterns", patterns });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get pattern(): ArrayPatternType {
+    return this.#pattern;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // Try to extract CBOR from the envelope
+    const cbor = haystack.asLeaf();
+    if (cbor === undefined) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    // Check if it's an array
+    const array = asCborArray(cbor);
+    if (array === undefined) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    switch (this.#pattern.type) {
+      case "Any":
+        return [[[haystack]], new Map<string, Path[]>()];
+
+      case "Interval": {
+        const length = array.length;
+        if (this.#pattern.interval.contains(length)) {
+          return [[[haystack]], new Map<string, Path[]>()];
+        }
+        return [[], new Map<string, Path[]>()];
+      }
+
+      case "DCBORPattern": {
+        // Delegate to dcbor-pattern for matching
+        const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
+          this.#pattern.pattern,
+          cbor,
+        );
+
+        if (dcborPaths.length > 0) {
+          // Convert dcbor paths to envelope paths
+          const envelopePaths: Path[] = dcborPaths.map((dcborPath: Cbor[]) => {
+            const envPath: Path = [haystack];
+            // Skip the first element (root) and convert rest to envelopes
+            for (let i = 1; i < dcborPath.length; i++) {
+              const elem = dcborPath[i];
+              if (elem !== undefined) {
+                envPath.push(Envelope.newLeaf(elem));
+              }
+            }
+            return envPath;
+          });
+
+          // Convert dcbor captures to envelope captures
+          const envelopeCaptures = new Map<string, Path[]>();
+          for (const [name, capturePaths] of dcborCaptures) {
+            const envCapturePaths: Path[] = capturePaths.map((dcborPath: Cbor[]) => {
+              const envPath: Path = [haystack];
+              for (let i = 1; i < dcborPath.length; i++) {
+                const elem = dcborPath[i];
+                if (elem !== undefined) {
+                  envPath.push(Envelope.newLeaf(elem));
+                }
+              }
+              return envPath;
+            });
+            envelopeCaptures.set(name, envCapturePaths);
+          }
+
+          return [envelopePaths, envelopeCaptures];
+        }
+
+        return [[], new Map<string, Path[]>()];
+      }
+
+      case "WithPatterns":
+        // For envelope patterns, match if array length equals patterns count
+        // Full element-by-element matching would require additional implementation
+        if (array.length === this.#pattern.patterns.length) {
+          return [[[haystack]], new Map<string, Path[]>()];
+        }
+        return [[], 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 (createLeafArrayPattern === undefined) {
+      throw new Error("ArrayPattern factory not registered");
+    }
+    compileAsAtomic(createLeafArrayPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "[*]";
+      case "Interval":
+        return `[{${this.#pattern.interval.toString()}}]`;
+      case "DCBORPattern":
+        return dcborPatternDisplay(this.#pattern.pattern);
+      case "WithPatterns":
+        return `[${this.#pattern.patterns.map(String).join(", ")}]`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: ArrayPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    switch (this.#pattern.type) {
+      case "Any":
+        return true;
+      case "Interval":
+        return this.#pattern.interval.equals(
+          (other.#pattern as { type: "Interval"; interval: Interval }).interval,
+        );
+      case "DCBORPattern":
+        // Compare using display representation
+        return (
+          dcborPatternDisplay(this.#pattern.pattern) ===
+          dcborPatternDisplay(
+            (other.#pattern as { type: "DCBORPattern"; pattern: DCBORPattern }).pattern,
+          )
+        );
+      case "WithPatterns": {
+        const otherPatterns = (other.#pattern as { type: "WithPatterns"; patterns: Pattern[] })
+          .patterns;
+        if (this.#pattern.patterns.length !== otherPatterns.length) return false;
+        for (let i = 0; i < this.#pattern.patterns.length; i++) {
+          if (this.#pattern.patterns[i] !== otherPatterns[i]) return false;
+        }
+        return true;
+      }
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "Interval":
+        // Simple hash based on min/max
+        return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+      case "DCBORPattern":
+        // Simple hash based on display string
+        return simpleStringHash(dcborPatternDisplay(this.#pattern.pattern));
+      case "WithPatterns":
+        return this.#pattern.patterns.length;
+    }
+  }
+}
+
+/**
+ * Simple string hash function for hashCode implementations.
+ */
+function simpleStringHash(str: string): number {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash; // Convert to 32-bit integer
+  }
+  return hash;
+}

package/src/pattern/leaf/bool-pattern.ts

@@ -0,0 +1,140 @@
+/**
+ * @bcts/envelope-pattern - Boolean pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust bool_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/bool-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import {
+  type BoolPattern as DCBORBoolPattern,
+  boolPatternAny,
+  boolPatternValue,
+  boolPatternPaths as dcborBoolPatternPaths,
+  boolPatternDisplay,
+} from "@bcts/dcbor-pattern";
+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 createLeafBoolPattern: ((pattern: BoolPattern) => Pattern) | undefined;
+
+export function registerBoolPatternFactory(factory: (pattern: BoolPattern) => Pattern): void {
+  createLeafBoolPattern = factory;
+}
+
+/**
+ * Pattern for matching boolean values.
+ *
+ * This is a wrapper around dcbor_pattern::BoolPattern that provides
+ * envelope-specific integration.
+ *
+ * Corresponds to the Rust `BoolPattern` struct in bool_pattern.rs
+ */
+export class BoolPattern implements Matcher {
+  readonly #inner: DCBORBoolPattern;
+
+  private constructor(inner: DCBORBoolPattern) {
+    this.#inner = inner;
+  }
+
+  /**
+   * Creates a new BoolPattern that matches any boolean value.
+   */
+  static any(): BoolPattern {
+    return new BoolPattern(boolPatternAny());
+  }
+
+  /**
+   * Creates a new BoolPattern that matches the specific boolean value.
+   */
+  static value(value: boolean): BoolPattern {
+    return new BoolPattern(boolPatternValue(value));
+  }
+
+  /**
+   * Creates a new BoolPattern from a dcbor-pattern BoolPattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORBoolPattern): BoolPattern {
+    return new BoolPattern(dcborPattern);
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern BoolPattern.
+   */
+  get inner(): DCBORBoolPattern {
+    return this.#inner;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // For leaf envelopes, extract the CBOR and delegate to dcbor-pattern
+    const cbor = haystack.asLeaf();
+    if (cbor !== undefined) {
+      // Delegate to dcbor-pattern for CBOR matching
+      const dcborPaths = dcborBoolPatternPaths(this.#inner, cbor);
+
+      // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
+      if (dcborPaths.length > 0) {
+        const envelopePaths: Path[] = [[haystack]];
+        const envelopeCaptures = new Map<string, Path[]>();
+        return [envelopePaths, envelopeCaptures];
+      }
+    }
+
+    // Not a leaf envelope or no match
+    return [[], 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 (createLeafBoolPattern === undefined) {
+      throw new Error("BoolPattern factory not registered");
+    }
+    compileAsAtomic(createLeafBoolPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return boolPatternDisplay(this.#inner);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: BoolPattern): boolean {
+    // Compare by variant and value
+    if (this.#inner.variant !== other.#inner.variant) {
+      return false;
+    }
+    if (this.#inner.variant === "Value" && other.#inner.variant === "Value") {
+      return this.#inner.value === other.#inner.value;
+    }
+    return true;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    // Simple hash based on variant and value
+    let hash = this.#inner.variant === "Any" ? 0 : 1;
+    if (this.#inner.variant === "Value") {
+      hash = hash * 31 + (this.#inner.value ? 1 : 0);
+    }
+    return hash;
+  }
+}

package/src/pattern/leaf/byte-string-pattern.ts

@@ -0,0 +1,172 @@
+/**
+ * @bcts/envelope-pattern - Byte string pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust byte_string_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/byte-string-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import {
+  type ByteStringPattern as DCBORByteStringPattern,
+  byteStringPatternAny,
+  byteStringPatternValue,
+  byteStringPatternBinaryRegex,
+  byteStringPatternPaths as dcborByteStringPatternPaths,
+  byteStringPatternDisplay,
+} from "@bcts/dcbor-pattern";
+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 createLeafByteStringPattern: ((pattern: ByteStringPattern) => Pattern) | undefined;
+
+export function registerByteStringPatternFactory(
+  factory: (pattern: ByteStringPattern) => Pattern,
+): void {
+  createLeafByteStringPattern = factory;
+}
+
+/**
+ * Pattern for matching byte string values.
+ *
+ * This is a wrapper around dcbor_pattern::ByteStringPattern that provides
+ * envelope-specific integration.
+ *
+ * Corresponds to the Rust `ByteStringPattern` struct in byte_string_pattern.rs
+ */
+export class ByteStringPattern implements Matcher {
+  readonly #inner: DCBORByteStringPattern;
+
+  private constructor(inner: DCBORByteStringPattern) {
+    this.#inner = inner;
+  }
+
+  /**
+   * Creates a new ByteStringPattern that matches any byte string.
+   */
+  static any(): ByteStringPattern {
+    return new ByteStringPattern(byteStringPatternAny());
+  }
+
+  /**
+   * Creates a new ByteStringPattern that matches the specific byte string.
+   */
+  static value(value: Uint8Array): ByteStringPattern {
+    return new ByteStringPattern(byteStringPatternValue(value));
+  }
+
+  /**
+   * Creates a new ByteStringPattern that matches byte strings matching the binary regex.
+   */
+  static regex(pattern: RegExp): ByteStringPattern {
+    return new ByteStringPattern(byteStringPatternBinaryRegex(pattern));
+  }
+
+  /**
+   * Creates a new ByteStringPattern from a dcbor-pattern ByteStringPattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORByteStringPattern): ByteStringPattern {
+    return new ByteStringPattern(dcborPattern);
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern ByteStringPattern.
+   */
+  get inner(): DCBORByteStringPattern {
+    return this.#inner;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // For leaf envelopes, extract the CBOR and delegate to dcbor-pattern
+    const cbor = haystack.asLeaf();
+    if (cbor !== undefined) {
+      // Delegate to dcbor-pattern for CBOR matching
+      const dcborPaths = dcborByteStringPatternPaths(this.#inner, cbor);
+
+      // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
+      if (dcborPaths.length > 0) {
+        const envelopePaths: Path[] = [[haystack]];
+        return [envelopePaths, new Map<string, Path[]>()];
+      }
+    }
+
+    return [[], 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 (createLeafByteStringPattern === undefined) {
+      throw new Error("ByteStringPattern factory not registered");
+    }
+    compileAsAtomic(createLeafByteStringPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return byteStringPatternDisplay(this.#inner);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: ByteStringPattern): boolean {
+    if (this.#inner.variant !== other.#inner.variant) {
+      return false;
+    }
+    switch (this.#inner.variant) {
+      case "Any":
+        return true;
+      case "Value": {
+        const a = (this.#inner as { value: Uint8Array }).value;
+        const b = (other.#inner as { value: Uint8Array }).value;
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+          if (a[i] !== b[i]) return false;
+        }
+        return true;
+      }
+      case "BinaryRegex":
+        return (
+          (this.#inner as { pattern: RegExp }).pattern.source ===
+          (other.#inner as { pattern: RegExp }).pattern.source
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    let hash = 0;
+    switch (this.#inner.variant) {
+      case "Any":
+        hash = 1;
+        break;
+      case "Value": {
+        const val = (this.#inner as { value: Uint8Array }).value;
+        for (const byte of val) {
+          hash = hash * 31 + byte;
+        }
+        break;
+      }
+      case "BinaryRegex":
+        hash = 3 * 31 + (this.#inner as { pattern: RegExp }).pattern.source.length;
+        break;
+    }
+    return hash;
+  }
+}