@bcts/envelope-pattern 1.0.0-alpha.12

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

@@ -0,0 +1,355 @@
+/**
+ * @bcts/envelope-pattern - CBOR pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust cbor_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/cbor-pattern
+ */
+
+import { Envelope } from "@bcts/envelope";
+import type { Cbor } from "@bcts/dcbor";
+import { cbor as toCbor, type CborInput } from "@bcts/dcbor";
+import {
+  type Pattern as DCBORPattern,
+  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 createLeafCBORPattern: ((pattern: CBORPattern) => Pattern) | undefined;
+
+export function registerCBORPatternFactory(factory: (pattern: CBORPattern) => Pattern): void {
+  createLeafCBORPattern = factory;
+}
+
+/**
+ * Pattern type for CBOR pattern matching.
+ *
+ * Corresponds to the Rust `CBORPattern` enum in cbor_pattern.rs
+ */
+export type CBORPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Value"; readonly cbor: Cbor }
+  | { readonly type: "Pattern"; readonly pattern: DCBORPattern };
+
+/**
+ * Pattern for matching CBOR values with support for exact values and advanced pattern matching.
+ *
+ * Corresponds to the Rust `CBORPattern` enum in cbor_pattern.rs
+ */
+export class CBORPattern implements Matcher {
+  readonly #pattern: CBORPatternType;
+
+  private constructor(pattern: CBORPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new CBORPattern that matches any CBOR value.
+   */
+  static any(): CBORPattern {
+    return new CBORPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new CBORPattern that matches a specific CBOR value.
+   */
+  static value(value: CborInput): CBORPattern {
+    return new CBORPattern({ type: "Value", cbor: toCbor(value) });
+  }
+
+  /**
+   * Creates a new CBORPattern that matches CBOR values using dcbor-pattern expressions.
+   */
+  static pattern(dcborPattern: DCBORPattern): CBORPattern {
+    return new CBORPattern({ type: "Pattern", pattern: dcborPattern });
+  }
+
+  /**
+   * Creates a new CBORPattern from a dcbor-pattern Pattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORPattern): CBORPattern {
+    return new CBORPattern({ type: "Pattern", pattern: dcborPattern });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get pattern(): CBORPatternType {
+    return this.#pattern;
+  }
+
+  /**
+   * Convert dcbor captures to envelope captures.
+   */
+  #convertDcborCapturesToEnvelopeCaptures(
+    dcborCaptures: Map<string, Cbor[][]>,
+    baseEnvelope: Envelope,
+    baseCbor: Cbor,
+  ): Map<string, Path[]> {
+    const envelopeCaptures = new Map<string, Path[]>();
+
+    for (const [captureName, dcborCapturePaths] of dcborCaptures) {
+      const envelopeCapturePaths: Path[] = dcborCapturePaths.map((dcborPath) =>
+        this.#convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor),
+      );
+      envelopeCaptures.set(captureName, envelopeCapturePaths);
+    }
+
+    return envelopeCaptures;
+  }
+
+  /**
+   * Convert a single dcbor path to an envelope path.
+   */
+  #convertDcborPathToEnvelopePath(
+    dcborPath: Cbor[],
+    baseEnvelope: Envelope,
+    baseCbor: Cbor,
+  ): Envelope[] {
+    const envelopePath: Envelope[] = [baseEnvelope];
+
+    // Skip first element if it matches the base envelope's CBOR content (compare by diagnostic)
+    const skipFirst =
+      dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === baseCbor.toDiagnostic();
+
+    const elementsToAdd = skipFirst ? dcborPath.slice(1) : dcborPath;
+
+    for (const cborElement of elementsToAdd) {
+      // Use newLeaf to create envelope from CBOR value
+      envelopePath.push(Envelope.newLeaf(cborElement));
+    }
+
+    return envelopePath;
+  }
+
+  /**
+   * Collect capture names from a dcbor pattern.
+   */
+  #collectDcborCaptureNames(dcborPattern: DCBORPattern, names: string[]): void {
+    // Parse the pattern string to extract capture names
+    const patternStr = dcborPatternDisplay(dcborPattern);
+
+    // Simple parsing to find @name( patterns
+    let i = 0;
+    while (i < patternStr.length) {
+      if (patternStr[i] === "@") {
+        i++;
+        let name = "";
+        // Collect characters until we hit '('
+        while (i < patternStr.length && patternStr[i] !== "(") {
+          name += patternStr[i];
+          i++;
+        }
+        if (name.length > 0 && !names.includes(name)) {
+          names.push(name);
+        }
+      } else {
+        i++;
+      }
+    }
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const envCase = haystack.case();
+
+    // Special case for KnownValue envelope
+    if (envCase.type === "knownValue") {
+      const knownValue = envCase.value;
+      const knownValueCbor = knownValue.taggedCbor();
+
+      switch (this.#pattern.type) {
+        case "Any":
+          return [[[haystack]], new Map<string, Path[]>()];
+        case "Value": {
+          // Compare using diagnostic representation
+          if (knownValueCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) {
+            return [[[haystack]], new Map<string, Path[]>()];
+          }
+          return [[], new Map<string, Path[]>()];
+        }
+        case "Pattern": {
+          const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
+            this.#pattern.pattern,
+            knownValueCbor,
+          );
+
+          if (dcborPaths.length > 0) {
+            const basePath: Path = [haystack];
+            const envelopePaths: Path[] = dcborPaths.map((dcborPath: Cbor[]) => {
+              const extendedPath = [...basePath];
+              // Skip the first element as it represents the root CBOR
+              for (let i = 1; i < dcborPath.length; i++) {
+                const elem = dcborPath[i];
+                if (elem !== undefined) {
+                  extendedPath.push(Envelope.newLeaf(elem));
+                }
+              }
+              return extendedPath;
+            });
+
+            const envelopeCaptures = this.#convertDcborCapturesToEnvelopeCaptures(
+              dcborCaptures,
+              haystack,
+              knownValueCbor,
+            );
+            return [envelopePaths, envelopeCaptures];
+          }
+          return [[], new Map<string, Path[]>()];
+        }
+      }
+    }
+
+    // Standard case for CBOR leaf
+    const leafCbor = haystack.asLeaf();
+    if (leafCbor === undefined) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    switch (this.#pattern.type) {
+      case "Any":
+        return [[[haystack]], new Map<string, Path[]>()];
+
+      case "Value":
+        // Compare using diagnostic representation
+        if (leafCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) {
+          return [[[haystack]], new Map<string, Path[]>()];
+        }
+        return [[], new Map<string, Path[]>()];
+
+      case "Pattern": {
+        const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
+          this.#pattern.pattern,
+          leafCbor,
+        );
+
+        if (dcborPaths.length > 0) {
+          const basePath: Path = [haystack];
+
+          const envelopePaths: Path[] = dcborPaths.map((dcborPath: Cbor[]) => {
+            const extendedPath = [...basePath];
+            // Skip the first element only if it exactly matches our root CBOR
+            const skipFirst =
+              dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === leafCbor.toDiagnostic();
+
+            const elementsToAdd = skipFirst ? dcborPath.slice(1) : dcborPath;
+
+            for (const cborElement of elementsToAdd) {
+              extendedPath.push(Envelope.newLeaf(cborElement));
+            }
+            return extendedPath;
+          });
+
+          const envelopeCaptures = this.#convertDcborCapturesToEnvelopeCaptures(
+            dcborCaptures,
+            haystack,
+            leafCbor,
+          );
+          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 {
+    // Register any capture names from this CBOR pattern
+    if (this.#pattern.type === "Pattern") {
+      const captureNames: string[] = [];
+      this.#collectDcborCaptureNames(this.#pattern.pattern, captureNames);
+      for (const name of captureNames) {
+        if (!captures.includes(name)) {
+          captures.push(name);
+        }
+      }
+    }
+
+    if (createLeafCBORPattern === undefined) {
+      throw new Error("CBORPattern factory not registered");
+    }
+    compileAsAtomic(createLeafCBORPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "cbor";
+      case "Value":
+        return `cbor(${this.#pattern.cbor.toDiagnostic()})`;
+      case "Pattern":
+        return `cbor(/${dcborPatternDisplay(this.#pattern.pattern)}/)`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: CBORPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    switch (this.#pattern.type) {
+      case "Any":
+        return true;
+      case "Value":
+        // Compare using diagnostic representation
+        return (
+          this.#pattern.cbor.toDiagnostic() ===
+          (other.#pattern as { type: "Value"; cbor: Cbor }).cbor.toDiagnostic()
+        );
+      case "Pattern":
+        // Compare using display representation
+        return (
+          dcborPatternDisplay(this.#pattern.pattern) ===
+          dcborPatternDisplay(
+            (other.#pattern as { type: "Pattern"; pattern: DCBORPattern }).pattern,
+          )
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "Value":
+        // Simple hash based on diagnostic string
+        return simpleStringHash(this.#pattern.cbor.toDiagnostic());
+      case "Pattern":
+        // Simple hash based on display string
+        return simpleStringHash(dcborPatternDisplay(this.#pattern.pattern));
+    }
+  }
+}
+
+/**
+ * Simple string hash function for hashCode implementations.
+ */
+function simpleStringHash(str: string): number {
+  let hash = 0;
+  for (const char of str) {
+    hash = (hash << 5) - hash + char.charCodeAt(0);
+    hash = hash & hash; // Convert to 32-bit integer
+  }
+  return hash;
+}

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

@@ -0,0 +1,178 @@
+/**
+ * @bcts/envelope-pattern - Date pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust date_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/date-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { CborDate } from "@bcts/dcbor";
+import {
+  type DatePattern as DCBORDatePattern,
+  datePatternAny,
+  datePatternValue,
+  datePatternRange,
+  datePatternEarliest,
+  datePatternLatest,
+  datePatternStringValue,
+  datePatternRegex,
+  datePatternPaths as dcborDatePatternPaths,
+  datePatternDisplay,
+} 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 createLeafDatePattern: ((pattern: DatePattern) => Pattern) | undefined;
+
+export function registerDatePatternFactory(factory: (pattern: DatePattern) => Pattern): void {
+  createLeafDatePattern = factory;
+}
+
+/**
+ * Pattern for matching date values.
+ *
+ * This is a wrapper around dcbor_pattern::DatePattern that provides
+ * envelope-specific integration.
+ *
+ * Corresponds to the Rust `DatePattern` struct in date_pattern.rs
+ */
+export class DatePattern implements Matcher {
+  readonly #inner: DCBORDatePattern;
+
+  private constructor(inner: DCBORDatePattern) {
+    this.#inner = inner;
+  }
+
+  /**
+   * Creates a new DatePattern that matches any date.
+   */
+  static any(): DatePattern {
+    return new DatePattern(datePatternAny());
+  }
+
+  /**
+   * Creates a new DatePattern that matches the specific date.
+   */
+  static value(date: CborDate): DatePattern {
+    return new DatePattern(datePatternValue(date));
+  }
+
+  /**
+   * Creates a new DatePattern that matches dates within a range (inclusive).
+   */
+  static range(start: CborDate, end: CborDate): DatePattern {
+    return new DatePattern(datePatternRange(start, end));
+  }
+
+  /**
+   * Creates a new DatePattern that matches dates on or after the specified date.
+   */
+  static earliest(date: CborDate): DatePattern {
+    return new DatePattern(datePatternEarliest(date));
+  }
+
+  /**
+   * Creates a new DatePattern that matches dates on or before the specified date.
+   */
+  static latest(date: CborDate): DatePattern {
+    return new DatePattern(datePatternLatest(date));
+  }
+
+  /**
+   * Creates a new DatePattern that matches dates by their ISO-8601 string representation.
+   */
+  static string(isoString: string): DatePattern {
+    return new DatePattern(datePatternStringValue(isoString));
+  }
+
+  /**
+   * Creates a new DatePattern that matches dates whose ISO-8601 string representation
+   * matches the given regular expression.
+   */
+  static regex(pattern: RegExp): DatePattern {
+    return new DatePattern(datePatternRegex(pattern));
+  }
+
+  /**
+   * Creates a new DatePattern from a dcbor-pattern DatePattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORDatePattern): DatePattern {
+    return new DatePattern(dcborPattern);
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern DatePattern.
+   */
+  get inner(): DCBORDatePattern {
+    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 = dcborDatePatternPaths(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 (createLeafDatePattern === undefined) {
+      throw new Error("DatePattern factory not registered");
+    }
+    compileAsAtomic(createLeafDatePattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return datePatternDisplay(this.#inner);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: DatePattern): boolean {
+    if (this.#inner.variant !== other.#inner.variant) {
+      return false;
+    }
+    // Simplified equality - compare variant names
+    return JSON.stringify(this.#inner) === JSON.stringify(other.#inner);
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    // Simple hash based on variant
+    let hash = 0;
+    const str = this.#inner.variant;
+    for (let i = 0; i < str.length; i++) {
+      hash = hash * 31 + str.charCodeAt(i);
+    }
+    return hash;
+  }
+}