@bcts/envelope-pattern 1.0.0-alpha.12

package/src/pattern/structure/index.ts

@@ -0,0 +1,272 @@
+/**
+ * @bcts/envelope-pattern - Structure patterns module
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust pattern/structure/mod.rs
+ *
+ * @module envelope-pattern/pattern/structure
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Re-export all structure pattern types
+export {
+  LeafStructurePattern,
+  registerLeafStructurePatternFactory,
+} from "./leaf-structure-pattern";
+export {
+  SubjectPattern,
+  type SubjectPatternType,
+  registerSubjectPatternFactory,
+} from "./subject-pattern";
+export {
+  PredicatePattern,
+  type PredicatePatternType,
+  registerPredicatePatternFactory,
+} from "./predicate-pattern";
+export {
+  ObjectPattern,
+  type ObjectPatternType,
+  registerObjectPatternFactory,
+} from "./object-pattern";
+export {
+  AssertionsPattern,
+  type AssertionsPatternType,
+  registerAssertionsPatternFactory,
+} from "./assertions-pattern";
+export {
+  DigestPattern,
+  type DigestPatternType,
+  registerDigestPatternFactory,
+} from "./digest-pattern";
+export { NodePattern, type NodePatternType, registerNodePatternFactory } from "./node-pattern";
+export {
+  ObscuredPattern,
+  type ObscuredPatternType,
+  registerObscuredPatternFactory,
+} from "./obscured-pattern";
+export {
+  WrappedPattern,
+  type WrappedPatternType,
+  registerWrappedPatternFactory,
+} from "./wrapped-pattern";
+
+// Import concrete types for use in StructurePattern
+import { type LeafStructurePattern } from "./leaf-structure-pattern";
+import { type SubjectPattern } from "./subject-pattern";
+import { type PredicatePattern } from "./predicate-pattern";
+import { type ObjectPattern } from "./object-pattern";
+import { type AssertionsPattern } from "./assertions-pattern";
+import { type DigestPattern } from "./digest-pattern";
+import { type NodePattern } from "./node-pattern";
+import { type ObscuredPattern } from "./obscured-pattern";
+import { type WrappedPattern } from "./wrapped-pattern";
+
+/**
+ * Union type for all structure patterns.
+ *
+ * Corresponds to the Rust `StructurePattern` enum in pattern/structure/mod.rs
+ */
+export type StructurePattern =
+  | { readonly type: "Leaf"; readonly pattern: LeafStructurePattern }
+  | { readonly type: "Subject"; readonly pattern: SubjectPattern }
+  | { readonly type: "Predicate"; readonly pattern: PredicatePattern }
+  | { readonly type: "Object"; readonly pattern: ObjectPattern }
+  | { readonly type: "Assertions"; readonly pattern: AssertionsPattern }
+  | { readonly type: "Digest"; readonly pattern: DigestPattern }
+  | { readonly type: "Node"; readonly pattern: NodePattern }
+  | { readonly type: "Obscured"; readonly pattern: ObscuredPattern }
+  | { readonly type: "Wrapped"; readonly pattern: WrappedPattern };
+
+/**
+ * Creates a Leaf structure pattern.
+ */
+export function structureLeaf(pattern: LeafStructurePattern): StructurePattern {
+  return { type: "Leaf", pattern };
+}
+
+/**
+ * Creates a Subject structure pattern.
+ */
+export function structureSubject(pattern: SubjectPattern): StructurePattern {
+  return { type: "Subject", pattern };
+}
+
+/**
+ * Creates a Predicate structure pattern.
+ */
+export function structurePredicate(pattern: PredicatePattern): StructurePattern {
+  return { type: "Predicate", pattern };
+}
+
+/**
+ * Creates an Object structure pattern.
+ */
+export function structureObject(pattern: ObjectPattern): StructurePattern {
+  return { type: "Object", pattern };
+}
+
+/**
+ * Creates an Assertions structure pattern.
+ */
+export function structureAssertions(pattern: AssertionsPattern): StructurePattern {
+  return { type: "Assertions", pattern };
+}
+
+/**
+ * Creates a Digest structure pattern.
+ */
+export function structureDigest(pattern: DigestPattern): StructurePattern {
+  return { type: "Digest", pattern };
+}
+
+/**
+ * Creates a Node structure pattern.
+ */
+export function structureNode(pattern: NodePattern): StructurePattern {
+  return { type: "Node", pattern };
+}
+
+/**
+ * Creates an Obscured structure pattern.
+ */
+export function structureObscured(pattern: ObscuredPattern): StructurePattern {
+  return { type: "Obscured", pattern };
+}
+
+/**
+ * Creates a Wrapped structure pattern.
+ */
+export function structureWrapped(pattern: WrappedPattern): StructurePattern {
+  return { type: "Wrapped", pattern };
+}
+
+/**
+ * Gets paths with captures for a structure pattern.
+ */
+export function structurePatternPathsWithCaptures(
+  pattern: StructurePattern,
+  haystack: Envelope,
+): [Path[], Map<string, Path[]>] {
+  switch (pattern.type) {
+    case "Leaf":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Subject":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Predicate":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Object":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Assertions":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Digest":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Node":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Obscured":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Wrapped":
+      return pattern.pattern.pathsWithCaptures(haystack);
+  }
+}
+
+/**
+ * Gets paths for a structure pattern.
+ */
+export function structurePatternPaths(pattern: StructurePattern, haystack: Envelope): Path[] {
+  return structurePatternPathsWithCaptures(pattern, haystack)[0];
+}
+
+/**
+ * Compiles a structure pattern to bytecode.
+ */
+export function structurePatternCompile(
+  pattern: StructurePattern,
+  code: Instr[],
+  literals: Pattern[],
+  captures: string[],
+): void {
+  switch (pattern.type) {
+    case "Leaf":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Subject":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Predicate":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Object":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Assertions":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Digest":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Node":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Obscured":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Wrapped":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+  }
+}
+
+/**
+ * Checks if a structure pattern is complex.
+ */
+export function structurePatternIsComplex(pattern: StructurePattern): boolean {
+  switch (pattern.type) {
+    case "Leaf":
+      return pattern.pattern.isComplex();
+    case "Subject":
+      return pattern.pattern.isComplex();
+    case "Predicate":
+      return pattern.pattern.isComplex();
+    case "Object":
+      return pattern.pattern.isComplex();
+    case "Assertions":
+      return pattern.pattern.isComplex();
+    case "Digest":
+      return pattern.pattern.isComplex();
+    case "Node":
+      return pattern.pattern.isComplex();
+    case "Obscured":
+      return pattern.pattern.isComplex();
+    case "Wrapped":
+      return pattern.pattern.isComplex();
+  }
+}
+
+/**
+ * Converts a structure pattern to string.
+ */
+export function structurePatternToString(pattern: StructurePattern): string {
+  switch (pattern.type) {
+    case "Leaf":
+      return pattern.pattern.toString();
+    case "Subject":
+      return pattern.pattern.toString();
+    case "Predicate":
+      return pattern.pattern.toString();
+    case "Object":
+      return pattern.pattern.toString();
+    case "Assertions":
+      return pattern.pattern.toString();
+    case "Digest":
+      return pattern.pattern.toString();
+    case "Node":
+      return pattern.pattern.toString();
+    case "Obscured":
+      return pattern.pattern.toString();
+    case "Wrapped":
+      return pattern.pattern.toString();
+  }
+}

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

@@ -0,0 +1,85 @@
+/**
+ * @bcts/envelope-pattern - Leaf structure pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust leaf_structure_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/leaf-structure-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+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 createStructureLeafPattern: ((pattern: LeafStructurePattern) => Pattern) | undefined;
+
+export function registerLeafStructurePatternFactory(
+  factory: (pattern: LeafStructurePattern) => Pattern,
+): void {
+  createStructureLeafPattern = factory;
+}
+
+/**
+ * Pattern for matching leaf envelopes (terminal nodes in the envelope tree).
+ *
+ * Corresponds to the Rust `LeafStructurePattern` struct in leaf_structure_pattern.rs
+ */
+export class LeafStructurePattern implements Matcher {
+  private constructor() {
+    // Empty constructor - LeafStructurePattern is a singleton-like pattern with no state
+  }
+
+  /**
+   * Creates a new LeafStructurePattern.
+   */
+  static new(): LeafStructurePattern {
+    return new LeafStructurePattern();
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const envCase = haystack.case();
+    const isLeafOrKnownValue = envCase.type === "leaf" || envCase.type === "knownValue";
+    const paths = isLeafOrKnownValue ? [[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 (createStructureLeafPattern === undefined) {
+      throw new Error("LeafStructurePattern factory not registered");
+    }
+    compileAsAtomic(createStructureLeafPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return "leaf";
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(_other: LeafStructurePattern): boolean {
+    return true; // All LeafStructurePattern instances are equal
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return 0;
+  }
+}

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

@@ -0,0 +1,188 @@
+/**
+ * @bcts/envelope-pattern - Node pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust node_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/node-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+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 createStructureNodePattern: ((pattern: NodePattern) => Pattern) | undefined;
+
+export function registerNodePatternFactory(factory: (pattern: NodePattern) => Pattern): void {
+  createStructureNodePattern = factory;
+}
+
+/**
+ * Pattern type for node pattern matching.
+ *
+ * Corresponds to the Rust `NodePattern` enum in node_pattern.rs
+ */
+export type NodePatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "AssertionsInterval"; readonly interval: Interval }
+  | { readonly type: "WithSubject"; readonly subjectPattern: Pattern };
+
+/**
+ * Pattern for matching node envelopes.
+ *
+ * Corresponds to the Rust `NodePattern` enum in node_pattern.rs
+ */
+export class NodePattern implements Matcher {
+  readonly #pattern: NodePatternType;
+
+  private constructor(pattern: NodePatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new NodePattern that matches any node.
+   */
+  static any(): NodePattern {
+    return new NodePattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new NodePattern that matches a node with the specified count of assertions.
+   */
+  static interval(min: number, max?: number): NodePattern {
+    const interval = max !== undefined ? Interval.from(min, max) : Interval.atLeast(min);
+    return new NodePattern({ type: "AssertionsInterval", interval });
+  }
+
+  /**
+   * Creates a new NodePattern from an Interval.
+   */
+  static fromInterval(interval: Interval): NodePattern {
+    return new NodePattern({ type: "AssertionsInterval", interval });
+  }
+
+  /**
+   * Creates a new NodePattern with a subject pattern constraint.
+   */
+  static withSubject(subjectPattern: Pattern): NodePattern {
+    return new NodePattern({ type: "WithSubject", subjectPattern });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): NodePatternType {
+    return this.#pattern;
+  }
+
+  /**
+   * Gets the subject pattern if this is a WithSubject type, undefined otherwise.
+   */
+  subjectPattern(): Pattern | undefined {
+    return this.#pattern.type === "WithSubject" ? this.#pattern.subjectPattern : undefined;
+  }
+
+  /**
+   * Gets the assertion patterns (empty array if none).
+   */
+  assertionPatterns(): Pattern[] {
+    // NodePattern doesn't support assertion patterns directly; return empty array
+    return [];
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    if (!haystack.isNode()) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    let isHit = false;
+
+    switch (this.#pattern.type) {
+      case "Any":
+        isHit = true;
+        break;
+      case "AssertionsInterval":
+        isHit = this.#pattern.interval.contains(haystack.assertions().length);
+        break;
+      case "WithSubject":
+        // For WithSubject, we match if the node exists (subject pattern matching done at higher level)
+        isHit = true;
+        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 (createStructureNodePattern === undefined) {
+      throw new Error("NodePattern factory not registered");
+    }
+    compileAsAtomic(createStructureNodePattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "node";
+      case "AssertionsInterval":
+        return `node(${this.#pattern.interval.toString()})`;
+      case "WithSubject":
+        return `node(${(this.#pattern.subjectPattern as unknown as { toString(): string }).toString()})`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: NodePattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    switch (this.#pattern.type) {
+      case "Any":
+        return true;
+      case "AssertionsInterval":
+        return this.#pattern.interval.equals(
+          (other.#pattern as { type: "AssertionsInterval"; interval: Interval }).interval,
+        );
+      case "WithSubject":
+        // Simple reference equality for pattern (could be improved with deep equality)
+        return (
+          this.#pattern.subjectPattern ===
+          (other.#pattern as { type: "WithSubject"; subjectPattern: Pattern }).subjectPattern
+        );
+    }
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "AssertionsInterval":
+        // Simple hash based on interval min/max
+        return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+      case "WithSubject":
+        return 1;
+    }
+  }
+}

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

@@ -0,0 +1,149 @@
+/**
+ * @bcts/envelope-pattern - Object pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust object_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/object-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 createStructureObjectPattern: ((pattern: ObjectPattern) => Pattern) | undefined;
+
+export function registerObjectPatternFactory(factory: (pattern: ObjectPattern) => Pattern): void {
+  createStructureObjectPattern = factory;
+}
+
+/**
+ * Pattern type for object pattern matching.
+ *
+ * Corresponds to the Rust `ObjectPattern` enum in object_pattern.rs
+ */
+export type ObjectPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Pattern"; readonly pattern: Pattern };
+
+/**
+ * Pattern for matching objects in envelopes.
+ *
+ * Corresponds to the Rust `ObjectPattern` enum in object_pattern.rs
+ */
+export class ObjectPattern implements Matcher {
+  readonly #pattern: ObjectPatternType;
+
+  private constructor(pattern: ObjectPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new ObjectPattern that matches any object.
+   */
+  static any(): ObjectPattern {
+    return new ObjectPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new ObjectPattern that matches objects matching the given pattern.
+   */
+  static pattern(pattern: Pattern): ObjectPattern {
+    return new ObjectPattern({ type: "Pattern", pattern });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): ObjectPatternType {
+    return this.#pattern;
+  }
+
+  /**
+   * Gets the inner pattern if this is a Pattern type, undefined otherwise.
+   */
+  innerPattern(): Pattern | undefined {
+    return this.#pattern.type === "Pattern" ? this.#pattern.pattern : undefined;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const object = haystack.asObject?.();
+
+    if (object === undefined) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    let paths: Path[];
+
+    switch (this.#pattern.type) {
+      case "Any":
+        paths = [[object]];
+        break;
+      case "Pattern": {
+        const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+        if (innerMatcher.matches(object)) {
+          paths = [[object]];
+        } else {
+          paths = [];
+        }
+        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 (createStructureObjectPattern === undefined) {
+      throw new Error("ObjectPattern factory not registered");
+    }
+    const idx = literals.length;
+    literals.push(createStructureObjectPattern(this));
+    code.push({ type: "MatchStructure", literalIndex: idx });
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "obj";
+      case "Pattern":
+        return `obj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: ObjectPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    if (this.#pattern.type === "Any") {
+      return true;
+    }
+    const thisPattern = (this.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const otherPattern = (other.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    return thisPattern === otherPattern;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return this.#pattern.type === "Any" ? 0 : 1;
+  }
+}