@bcts/envelope-pattern 1.0.0-alpha.12

package/src/pattern/leaf/index.ts

@@ -0,0 +1,280 @@
+/**
+ * @bcts/envelope-pattern - Leaf patterns module
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust pattern/leaf/mod.rs
+ *
+ * @module envelope-pattern/pattern/leaf
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Re-export all leaf pattern types
+export { BoolPattern, registerBoolPatternFactory } from "./bool-pattern";
+export { NullPattern, registerNullPatternFactory } from "./null-pattern";
+export { NumberPattern, registerNumberPatternFactory } from "./number-pattern";
+export { TextPattern, registerTextPatternFactory } from "./text-pattern";
+export { ByteStringPattern, registerByteStringPatternFactory } from "./byte-string-pattern";
+export { DatePattern, registerDatePatternFactory } from "./date-pattern";
+export { ArrayPattern, type ArrayPatternType, registerArrayPatternFactory } from "./array-pattern";
+export { MapPattern, type MapPatternType, registerMapPatternFactory } from "./map-pattern";
+export { KnownValuePattern, registerKnownValuePatternFactory } from "./known-value-pattern";
+export { TaggedPattern, registerTaggedPatternFactory } from "./tagged-pattern";
+export { CBORPattern, type CBORPatternType, registerCBORPatternFactory } from "./cbor-pattern";
+
+// Import concrete types for use in LeafPattern
+import { type BoolPattern } from "./bool-pattern";
+import { type NullPattern } from "./null-pattern";
+import { type NumberPattern } from "./number-pattern";
+import { type TextPattern } from "./text-pattern";
+import { type ByteStringPattern } from "./byte-string-pattern";
+import { type DatePattern } from "./date-pattern";
+import { type ArrayPattern } from "./array-pattern";
+import { type MapPattern } from "./map-pattern";
+import { type KnownValuePattern } from "./known-value-pattern";
+import { type TaggedPattern } from "./tagged-pattern";
+import { type CBORPattern } from "./cbor-pattern";
+
+/**
+ * Union type for all leaf patterns.
+ *
+ * Corresponds to the Rust `LeafPattern` enum in pattern/leaf/mod.rs
+ */
+export type LeafPattern =
+  | { readonly type: "Cbor"; readonly pattern: CBORPattern }
+  | { readonly type: "Number"; readonly pattern: NumberPattern }
+  | { readonly type: "Text"; readonly pattern: TextPattern }
+  | { readonly type: "ByteString"; readonly pattern: ByteStringPattern }
+  | { readonly type: "Tag"; readonly pattern: TaggedPattern }
+  | { readonly type: "Array"; readonly pattern: ArrayPattern }
+  | { readonly type: "Map"; readonly pattern: MapPattern }
+  | { readonly type: "Bool"; readonly pattern: BoolPattern }
+  | { readonly type: "Null"; readonly pattern: NullPattern }
+  | { readonly type: "Date"; readonly pattern: DatePattern }
+  | { readonly type: "KnownValue"; readonly pattern: KnownValuePattern };
+
+/**
+ * Creates a CBOR leaf pattern.
+ */
+export function leafCbor(pattern: CBORPattern): LeafPattern {
+  return { type: "Cbor", pattern };
+}
+
+/**
+ * Creates a Number leaf pattern.
+ */
+export function leafNumber(pattern: NumberPattern): LeafPattern {
+  return { type: "Number", pattern };
+}
+
+/**
+ * Creates a Text leaf pattern.
+ */
+export function leafText(pattern: TextPattern): LeafPattern {
+  return { type: "Text", pattern };
+}
+
+/**
+ * Creates a ByteString leaf pattern.
+ */
+export function leafByteString(pattern: ByteStringPattern): LeafPattern {
+  return { type: "ByteString", pattern };
+}
+
+/**
+ * Creates a Tag leaf pattern.
+ */
+export function leafTag(pattern: TaggedPattern): LeafPattern {
+  return { type: "Tag", pattern };
+}
+
+/**
+ * Creates an Array leaf pattern.
+ */
+export function leafArray(pattern: ArrayPattern): LeafPattern {
+  return { type: "Array", pattern };
+}
+
+/**
+ * Creates a Map leaf pattern.
+ */
+export function leafMap(pattern: MapPattern): LeafPattern {
+  return { type: "Map", pattern };
+}
+
+/**
+ * Creates a Bool leaf pattern.
+ */
+export function leafBool(pattern: BoolPattern): LeafPattern {
+  return { type: "Bool", pattern };
+}
+
+/**
+ * Creates a Null leaf pattern.
+ */
+export function leafNull(pattern: NullPattern): LeafPattern {
+  return { type: "Null", pattern };
+}
+
+/**
+ * Creates a Date leaf pattern.
+ */
+export function leafDate(pattern: DatePattern): LeafPattern {
+  return { type: "Date", pattern };
+}
+
+/**
+ * Creates a KnownValue leaf pattern.
+ */
+export function leafKnownValue(pattern: KnownValuePattern): LeafPattern {
+  return { type: "KnownValue", pattern };
+}
+
+/**
+ * Gets paths with captures for a leaf pattern.
+ */
+export function leafPatternPathsWithCaptures(
+  pattern: LeafPattern,
+  haystack: Envelope,
+): [Path[], Map<string, Path[]>] {
+  switch (pattern.type) {
+    case "Cbor":
+      // CBOR patterns from dcbor-pattern need special handling
+      return [[], new Map<string, Path[]>()];
+    case "Number":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Text":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "ByteString":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Tag":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Array":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Map":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Bool":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Null":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Date":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "KnownValue":
+      return pattern.pattern.pathsWithCaptures(haystack);
+  }
+}
+
+/**
+ * Gets paths for a leaf pattern.
+ */
+export function leafPatternPaths(pattern: LeafPattern, haystack: Envelope): Path[] {
+  return leafPatternPathsWithCaptures(pattern, haystack)[0];
+}
+
+/**
+ * Compiles a leaf pattern to bytecode.
+ */
+export function leafPatternCompile(
+  pattern: LeafPattern,
+  code: Instr[],
+  literals: Pattern[],
+  captures: string[],
+): void {
+  switch (pattern.type) {
+    case "Cbor":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Number":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Text":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "ByteString":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Tag":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Array":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Map":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Bool":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Null":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Date":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "KnownValue":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+  }
+}
+
+/**
+ * Checks if a leaf pattern is complex.
+ */
+export function leafPatternIsComplex(pattern: LeafPattern): boolean {
+  switch (pattern.type) {
+    case "Cbor":
+      return pattern.pattern.isComplex();
+    case "Number":
+      return pattern.pattern.isComplex();
+    case "Text":
+      return pattern.pattern.isComplex();
+    case "ByteString":
+      return pattern.pattern.isComplex();
+    case "Tag":
+      return pattern.pattern.isComplex();
+    case "Array":
+      return pattern.pattern.isComplex();
+    case "Map":
+      return pattern.pattern.isComplex();
+    case "Bool":
+      return pattern.pattern.isComplex();
+    case "Null":
+      return pattern.pattern.isComplex();
+    case "Date":
+      return pattern.pattern.isComplex();
+    case "KnownValue":
+      return pattern.pattern.isComplex();
+  }
+}
+
+/**
+ * Converts a leaf pattern to string.
+ */
+export function leafPatternToString(pattern: LeafPattern): string {
+  switch (pattern.type) {
+    case "Cbor":
+      return pattern.pattern.toString();
+    case "Number":
+      return pattern.pattern.toString();
+    case "Text":
+      return pattern.pattern.toString();
+    case "ByteString":
+      return pattern.pattern.toString();
+    case "Tag":
+      return pattern.pattern.toString();
+    case "Array":
+      return pattern.pattern.toString();
+    case "Map":
+      return pattern.pattern.toString();
+    case "Bool":
+      return pattern.pattern.toString();
+    case "Null":
+      return pattern.pattern.toString();
+    case "Date":
+      return pattern.pattern.toString();
+    case "KnownValue":
+      return pattern.pattern.toString();
+  }
+}

package/src/pattern/leaf/known-value-pattern.ts

@@ -0,0 +1,192 @@
+/**
+ * @bcts/envelope-pattern - Known value pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust known_value_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/known-value-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import { type KnownValue } from "@bcts/known-values";
+import {
+  type KnownValuePattern as DCBORKnownValuePattern,
+  knownValuePatternAny,
+  knownValuePatternValue,
+  knownValuePatternNamed,
+  knownValuePatternRegex,
+  knownValuePatternMatches,
+  knownValuePatternDisplay,
+} 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 createLeafKnownValuePattern: ((pattern: KnownValuePattern) => Pattern) | undefined;
+
+export function registerKnownValuePatternFactory(
+  factory: (pattern: KnownValuePattern) => Pattern,
+): void {
+  createLeafKnownValuePattern = factory;
+}
+
+/**
+ * Pattern for matching known values.
+ *
+ * This is a wrapper around dcbor_pattern::KnownValuePattern that provides
+ * envelope-specific integration.
+ *
+ * Corresponds to the Rust `KnownValuePattern` struct in known_value_pattern.rs
+ */
+export class KnownValuePattern implements Matcher {
+  readonly #inner: DCBORKnownValuePattern;
+
+  private constructor(inner: DCBORKnownValuePattern) {
+    this.#inner = inner;
+  }
+
+  /**
+   * Creates a new KnownValuePattern that matches any known value.
+   */
+  static any(): KnownValuePattern {
+    return new KnownValuePattern(knownValuePatternAny());
+  }
+
+  /**
+   * Creates a new KnownValuePattern that matches the specific known value.
+   */
+  static value(value: KnownValue): KnownValuePattern {
+    return new KnownValuePattern(knownValuePatternValue(value));
+  }
+
+  /**
+   * Creates a new KnownValuePattern that matches known values by name.
+   */
+  static named(name: string): KnownValuePattern {
+    return new KnownValuePattern(knownValuePatternNamed(name));
+  }
+
+  /**
+   * Creates a new KnownValuePattern that matches known values by regex on their name.
+   */
+  static regex(regex: RegExp): KnownValuePattern {
+    return new KnownValuePattern(knownValuePatternRegex(regex));
+  }
+
+  /**
+   * Creates a new KnownValuePattern from a dcbor-pattern KnownValuePattern.
+   */
+  static fromDcborPattern(dcborPattern: DCBORKnownValuePattern): KnownValuePattern {
+    return new KnownValuePattern(dcborPattern);
+  }
+
+  /**
+   * Gets the underlying dcbor-pattern KnownValuePattern.
+   */
+  get inner(): DCBORKnownValuePattern {
+    return this.#inner;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // Check if the envelope is a known value via case()
+    const envCase = haystack.case();
+
+    if (envCase.type === "knownValue") {
+      // Get the KnownValue and create CBOR for pattern matching
+      const knownValueCbor = envCase.value.taggedCbor();
+      if (knownValuePatternMatches(this.#inner, knownValueCbor)) {
+        return [[[haystack]], new Map<string, Path[]>()];
+      }
+    }
+
+    // Also try matching as a leaf (for tagged CBOR containing known values)
+    const leafCbor = haystack.asLeaf();
+    if (leafCbor !== undefined) {
+      if (knownValuePatternMatches(this.#inner, leafCbor)) {
+        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 (createLeafKnownValuePattern === undefined) {
+      throw new Error("KnownValuePattern factory not registered");
+    }
+    compileAsAtomic(createLeafKnownValuePattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return knownValuePatternDisplay(this.#inner);
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: KnownValuePattern): 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 "Value":
+        return (
+          this.#inner.value.valueBigInt() ===
+          (other.#inner as { variant: "Value"; value: KnownValue }).value.valueBigInt()
+        );
+      case "Named":
+        return this.#inner.name === (other.#inner as { variant: "Named"; name: string }).name;
+      case "Regex":
+        return (
+          this.#inner.pattern.source ===
+          (other.#inner as { variant: "Regex"; pattern: RegExp }).pattern.source
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#inner.variant) {
+      case "Any":
+        return 0;
+      case "Value":
+        return Number(this.#inner.value.valueBigInt() & BigInt(0xffffffff));
+      case "Named":
+        return simpleStringHash(this.#inner.name);
+      case "Regex":
+        return simpleStringHash(this.#inner.pattern.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;
+}

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

@@ -0,0 +1,152 @@
+/**
+ * @bcts/envelope-pattern - Map pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust map_pattern.rs
+ *
+ * @module envelope-pattern/pattern/leaf/map-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import { asCborMap } from "@bcts/dcbor";
+import { Interval } 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 createLeafMapPattern: ((pattern: MapPattern) => Pattern) | undefined;
+
+export function registerMapPatternFactory(factory: (pattern: MapPattern) => Pattern): void {
+  createLeafMapPattern = factory;
+}
+
+/**
+ * Pattern for matching map values.
+ *
+ * Corresponds to the Rust `MapPattern` enum in map_pattern.rs
+ */
+export type MapPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Interval"; readonly interval: Interval };
+
+/**
+ * Pattern for matching map values in envelope leaf nodes.
+ *
+ * Corresponds to the Rust `MapPattern` struct in map_pattern.rs
+ */
+export class MapPattern implements Matcher {
+  readonly #pattern: MapPatternType;
+
+  private constructor(pattern: MapPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new MapPattern that matches any map.
+   */
+  static any(): MapPattern {
+    return new MapPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new MapPattern that matches maps within a size range.
+   */
+  static interval(min: number, max?: number): MapPattern {
+    const interval = max !== undefined ? Interval.from(min, max) : Interval.atLeast(min);
+    return new MapPattern({ type: "Interval", interval });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get pattern(): MapPatternType {
+    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 a map
+    const map = asCborMap(cbor);
+    if (map === undefined) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    switch (this.#pattern.type) {
+      case "Any":
+        return [[[haystack]], new Map<string, Path[]>()];
+
+      case "Interval": {
+        const size = map.size;
+        if (this.#pattern.interval.contains(size)) {
+          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 (createLeafMapPattern === undefined) {
+      throw new Error("MapPattern factory not registered");
+    }
+    compileAsAtomic(createLeafMapPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "{*}";
+      case "Interval":
+        return `{{${this.#pattern.interval.toString()}}}`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: MapPattern): 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,
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "Interval":
+        // Simple hash based on interval min/max
+        return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+    }
+  }
+}