@bcts/envelope-pattern 1.0.0-alpha.12

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

@@ -0,0 +1,110 @@
+/**
+ * @bcts/envelope-pattern - Null pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust null_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/null-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import {
+  type NullPattern as DCBORNullPattern,
+  nullPatternPaths as dcborNullPatternPaths,
+  nullPatternDisplay,
+} 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 createLeafNullPattern: ((pattern: NullPattern) => Pattern) | undefined;
+
+export function registerNullPatternFactory(factory: (pattern: NullPattern) => Pattern): void {
+  createLeafNullPattern = factory;
+}
+
+/**
+ * Pattern for matching null values.
+ *
+ * This is a wrapper around dcbor_pattern::NullPattern that provides
+ * envelope-specific functionality.
+ *
+ * Corresponds to the Rust `NullPattern` struct in null_pattern.rs
+ */
+export class NullPattern implements Matcher {
+  readonly #inner: DCBORNullPattern;
+  static readonly #instance = new NullPattern();
+
+  private constructor() {
+    // Create the NullPattern directly - it's just { variant: "Null" }
+    this.#inner = { variant: "Null" };
+  }
+
+  /**
+   * Creates a new NullPattern (returns singleton).
+   */
+  static new(): NullPattern {
+    return NullPattern.#instance;
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern NullPattern.
+   */
+  get inner(): DCBORNullPattern {
+    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 = dcborNullPatternPaths(this.#inner, cbor);
+
+      if (dcborPaths.length > 0) {
+        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 (createLeafNullPattern === undefined) {
+      throw new Error("NullPattern factory not registered");
+    }
+    compileAsAtomic(createLeafNullPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return nullPatternDisplay(this.#inner);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: NullPattern): boolean {
+    return other instanceof NullPattern;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return 0; // All NullPatterns are equal
+  }
+}

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

@@ -0,0 +1,248 @@
+/**
+ * @bcts/envelope-pattern - Number pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust number_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/number-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import {
+  type NumberPattern as DCBORNumberPattern,
+  numberPatternAny,
+  numberPatternValue,
+  numberPatternRange,
+  numberPatternGreaterThan,
+  numberPatternGreaterThanOrEqual,
+  numberPatternLessThan,
+  numberPatternLessThanOrEqual,
+  numberPatternNaN,
+  numberPatternInfinity,
+  numberPatternNegInfinity,
+  numberPatternPaths as dcborNumberPatternPaths,
+  numberPatternDisplay,
+} 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 createLeafNumberPattern: ((pattern: NumberPattern) => Pattern) | undefined;
+
+export function registerNumberPatternFactory(factory: (pattern: NumberPattern) => Pattern): void {
+  createLeafNumberPattern = factory;
+}
+
+/**
+ * Pattern for matching number values.
+ *
+ * This is a wrapper around dcbor_pattern::NumberPattern that provides
+ * envelope-specific integration.
+ *
+ * Corresponds to the Rust `NumberPattern` struct in number_pattern.rs
+ */
+export class NumberPattern implements Matcher {
+  readonly #inner: DCBORNumberPattern;
+
+  private constructor(inner: DCBORNumberPattern) {
+    this.#inner = inner;
+  }
+
+  /**
+   * Creates a new NumberPattern that matches any number.
+   */
+  static any(): NumberPattern {
+    return new NumberPattern(numberPatternAny());
+  }
+
+  /**
+   * Creates a new NumberPattern that matches the exact number.
+   */
+  static exact(value: number): NumberPattern {
+    return new NumberPattern(numberPatternValue(value));
+  }
+
+  /**
+   * Creates a new NumberPattern that matches numbers within the specified range.
+   */
+  static range(min: number, max: number): NumberPattern {
+    return new NumberPattern(numberPatternRange(min, max));
+  }
+
+  /**
+   * Creates a new NumberPattern that matches numbers greater than the specified value.
+   */
+  static greaterThan(value: number): NumberPattern {
+    return new NumberPattern(numberPatternGreaterThan(value));
+  }
+
+  /**
+   * Creates a new NumberPattern that matches numbers greater than or equal to the specified value.
+   */
+  static greaterThanOrEqual(value: number): NumberPattern {
+    return new NumberPattern(numberPatternGreaterThanOrEqual(value));
+  }
+
+  /**
+   * Creates a new NumberPattern that matches numbers less than the specified value.
+   */
+  static lessThan(value: number): NumberPattern {
+    return new NumberPattern(numberPatternLessThan(value));
+  }
+
+  /**
+   * Creates a new NumberPattern that matches numbers less than or equal to the specified value.
+   */
+  static lessThanOrEqual(value: number): NumberPattern {
+    return new NumberPattern(numberPatternLessThanOrEqual(value));
+  }
+
+  /**
+   * Creates a new NumberPattern that matches NaN values.
+   */
+  static nan(): NumberPattern {
+    return new NumberPattern(numberPatternNaN());
+  }
+
+  /**
+   * Creates a new NumberPattern that matches positive infinity.
+   */
+  static infinity(): NumberPattern {
+    return new NumberPattern(numberPatternInfinity());
+  }
+
+  /**
+   * Creates a new NumberPattern that matches negative infinity.
+   */
+  static negInfinity(): NumberPattern {
+    return new NumberPattern(numberPatternNegInfinity());
+  }
+
+  /**
+   * Creates a new NumberPattern from a dcbor-pattern NumberPattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORNumberPattern): NumberPattern {
+    return new NumberPattern(dcborPattern);
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern NumberPattern.
+   */
+  get inner(): DCBORNumberPattern {
+    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 = dcborNumberPatternPaths(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 (createLeafNumberPattern === undefined) {
+      throw new Error("NumberPattern factory not registered");
+    }
+    compileAsAtomic(createLeafNumberPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return numberPatternDisplay(this.#inner);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: NumberPattern): boolean {
+    // Compare by variant and values
+    if (this.#inner.variant !== other.#inner.variant) {
+      return false;
+    }
+    switch (this.#inner.variant) {
+      case "Any":
+      case "NaN":
+      case "Infinity":
+      case "NegInfinity":
+        return true;
+      case "Value":
+      case "GreaterThan":
+      case "GreaterThanOrEqual":
+      case "LessThan":
+      case "LessThanOrEqual":
+        return (
+          (this.#inner as { value: number }).value === (other.#inner as { value: number }).value
+        );
+      case "Range":
+        return (
+          (this.#inner as { min: number; max: number }).min ===
+            (other.#inner as { min: number; max: number }).min &&
+          (this.#inner as { min: number; max: number }).max ===
+            (other.#inner as { min: number; max: number }).max
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    let hash = 0;
+    switch (this.#inner.variant) {
+      case "Any":
+        hash = 1;
+        break;
+      case "Value":
+        hash = 2 * 31 + (this.#inner as { value: number }).value;
+        break;
+      case "Range":
+        hash = 3 * 31 + (this.#inner as { min: number }).min + (this.#inner as { max: number }).max;
+        break;
+      case "GreaterThan":
+        hash = 4 * 31 + (this.#inner as { value: number }).value;
+        break;
+      case "GreaterThanOrEqual":
+        hash = 5 * 31 + (this.#inner as { value: number }).value;
+        break;
+      case "LessThan":
+        hash = 6 * 31 + (this.#inner as { value: number }).value;
+        break;
+      case "LessThanOrEqual":
+        hash = 7 * 31 + (this.#inner as { value: number }).value;
+        break;
+      case "NaN":
+        hash = 8;
+        break;
+      case "Infinity":
+        hash = 9;
+        break;
+      case "NegInfinity":
+        hash = 10;
+        break;
+    }
+    return hash;
+  }
+}

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

@@ -0,0 +1,228 @@
+/**
+ * @bcts/envelope-pattern - Tagged pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust tagged_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/tagged-pattern
+ */
+
+import { Envelope } from "@bcts/envelope";
+import type { Tag, Cbor } from "@bcts/dcbor";
+import {
+  type TaggedPattern as DCBORTaggedPattern,
+  type Pattern as DCBORPattern,
+  taggedPatternAny,
+  taggedPatternWithTag,
+  taggedPatternWithName,
+  taggedPatternWithRegex,
+  taggedPatternPathsWithCaptures,
+  taggedPatternDisplay,
+  patternDisplay,
+} 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 createLeafTaggedPattern: ((pattern: TaggedPattern) => Pattern) | undefined;
+
+export function registerTaggedPatternFactory(factory: (pattern: TaggedPattern) => Pattern): void {
+  createLeafTaggedPattern = factory;
+}
+
+/**
+ * Pattern for matching tagged CBOR values.
+ *
+ * This is a wrapper around dcbor_pattern::TaggedPattern that provides
+ * envelope-specific integration.
+ *
+ * Corresponds to the Rust `TaggedPattern` struct in tagged_pattern.rs
+ */
+export class TaggedPattern implements Matcher {
+  readonly #inner: DCBORTaggedPattern;
+
+  private constructor(inner: DCBORTaggedPattern) {
+    this.#inner = inner;
+  }
+
+  /**
+   * Creates a new TaggedPattern that matches any tagged value.
+   */
+  static any(): TaggedPattern {
+    return new TaggedPattern(taggedPatternAny());
+  }
+
+  /**
+   * Creates a new TaggedPattern with a specific tag and content pattern.
+   */
+  static withTag(tag: Tag, pattern: DCBORPattern): TaggedPattern {
+    return new TaggedPattern(taggedPatternWithTag(tag, pattern));
+  }
+
+  /**
+   * Creates a new TaggedPattern with a specific tag name and content pattern.
+   */
+  static withName(name: string, pattern: DCBORPattern): TaggedPattern {
+    return new TaggedPattern(taggedPatternWithName(name, pattern));
+  }
+
+  /**
+   * Creates a new TaggedPattern with a tag name matching regex and content pattern.
+   */
+  static withRegex(regex: RegExp, pattern: DCBORPattern): TaggedPattern {
+    return new TaggedPattern(taggedPatternWithRegex(regex, pattern));
+  }
+
+  /**
+   * Creates a new TaggedPattern from a dcbor-pattern TaggedPattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORTaggedPattern): TaggedPattern {
+    return new TaggedPattern(dcborPattern);
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern TaggedPattern.
+   */
+  get inner(): DCBORTaggedPattern {
+    return this.#inner;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // Try to extract CBOR from the envelope
+    const subject = haystack.subject();
+    const cbor = subject.asLeaf();
+
+    if (cbor !== undefined) {
+      // Delegate to dcbor-pattern for CBOR matching
+      const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this.#inner, 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, paths] of dcborCaptures) {
+          const envCapturePaths: Path[] = paths.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[]>()];
+  }
+
+  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 (createLeafTaggedPattern === undefined) {
+      throw new Error("TaggedPattern factory not registered");
+    }
+    compileAsAtomic(createLeafTaggedPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return taggedPatternDisplay(this.#inner, patternDisplay);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: TaggedPattern): boolean {
+    // Compare by variant type and values
+    if (this.#inner.variant !== other.#inner.variant) {
+      return false;
+    }
+    switch (this.#inner.variant) {
+      case "Any":
+        return true;
+      case "Tag": {
+        const otherTag = other.#inner as { variant: "Tag"; tag: Tag; pattern: DCBORPattern };
+        return (
+          this.#inner.tag.value === otherTag.tag.value &&
+          patternDisplay(this.#inner.pattern) === patternDisplay(otherTag.pattern)
+        );
+      }
+      case "Name": {
+        const otherName = other.#inner as { variant: "Name"; name: string; pattern: DCBORPattern };
+        return (
+          this.#inner.name === otherName.name &&
+          patternDisplay(this.#inner.pattern) === patternDisplay(otherName.pattern)
+        );
+      }
+      case "Regex": {
+        const otherRegex = other.#inner as {
+          variant: "Regex";
+          regex: RegExp;
+          pattern: DCBORPattern;
+        };
+        return (
+          this.#inner.regex.source === otherRegex.regex.source &&
+          patternDisplay(this.#inner.pattern) === patternDisplay(otherRegex.pattern)
+        );
+      }
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#inner.variant) {
+      case "Any":
+        return 0;
+      case "Tag":
+        return Number(BigInt(this.#inner.tag.value) & BigInt(0xffffffff));
+      case "Name":
+        return simpleStringHash(this.#inner.name);
+      case "Regex":
+        return simpleStringHash(this.#inner.regex.source);
+    }
+  }
+}
+
+/**
+ * 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;
+}