@bcts/envelope-pattern 1.0.0-alpha.12

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

@@ -0,0 +1,159 @@
+/**
+ * @bcts/envelope-pattern - Obscured pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust obscured_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/obscured-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 createStructureObscuredPattern: ((pattern: ObscuredPattern) => Pattern) | undefined;
+
+export function registerObscuredPatternFactory(
+  factory: (pattern: ObscuredPattern) => Pattern,
+): void {
+  createStructureObscuredPattern = factory;
+}
+
+/**
+ * Pattern type for obscured pattern matching.
+ *
+ * Corresponds to the Rust `ObscuredPattern` enum in obscured_pattern.rs
+ */
+export type ObscuredPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Elided" }
+  | { readonly type: "Encrypted" }
+  | { readonly type: "Compressed" };
+
+/**
+ * Pattern for matching obscured elements.
+ *
+ * Corresponds to the Rust `ObscuredPattern` enum in obscured_pattern.rs
+ */
+export class ObscuredPattern implements Matcher {
+  readonly #pattern: ObscuredPatternType;
+
+  private constructor(pattern: ObscuredPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new ObscuredPattern that matches any obscured element.
+   */
+  static any(): ObscuredPattern {
+    return new ObscuredPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new ObscuredPattern that matches any elided element.
+   */
+  static elided(): ObscuredPattern {
+    return new ObscuredPattern({ type: "Elided" });
+  }
+
+  /**
+   * Creates a new ObscuredPattern that matches any encrypted element.
+   */
+  static encrypted(): ObscuredPattern {
+    return new ObscuredPattern({ type: "Encrypted" });
+  }
+
+  /**
+   * Creates a new ObscuredPattern that matches any compressed element.
+   */
+  static compressed(): ObscuredPattern {
+    return new ObscuredPattern({ type: "Compressed" });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): ObscuredPatternType {
+    return this.#pattern;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    let isHit = false;
+
+    switch (this.#pattern.type) {
+      case "Any":
+        isHit = haystack.isObscured();
+        break;
+      case "Elided":
+        isHit = haystack.isElided();
+        break;
+      case "Encrypted":
+        isHit = haystack.isEncrypted();
+        break;
+      case "Compressed":
+        isHit = haystack.isCompressed();
+        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 (createStructureObscuredPattern === undefined) {
+      throw new Error("ObscuredPattern factory not registered");
+    }
+    compileAsAtomic(createStructureObscuredPattern(this), code, literals, captures);
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "obscured";
+      case "Elided":
+        return "elided";
+      case "Encrypted":
+        return "encrypted";
+      case "Compressed":
+        return "compressed";
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: ObscuredPattern): boolean {
+    return this.#pattern.type === other.#pattern.type;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    switch (this.#pattern.type) {
+      case "Any":
+        return 0;
+      case "Elided":
+        return 1;
+      case "Encrypted":
+        return 2;
+      case "Compressed":
+        return 3;
+    }
+  }
+}

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

@@ -0,0 +1,151 @@
+/**
+ * @bcts/envelope-pattern - Predicate pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust predicate_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/predicate-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 createStructurePredicatePattern: ((pattern: PredicatePattern) => Pattern) | undefined;
+
+export function registerPredicatePatternFactory(
+  factory: (pattern: PredicatePattern) => Pattern,
+): void {
+  createStructurePredicatePattern = factory;
+}
+
+/**
+ * Pattern type for predicate pattern matching.
+ *
+ * Corresponds to the Rust `PredicatePattern` enum in predicate_pattern.rs
+ */
+export type PredicatePatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Pattern"; readonly pattern: Pattern };
+
+/**
+ * Pattern for matching predicates in envelopes.
+ *
+ * Corresponds to the Rust `PredicatePattern` enum in predicate_pattern.rs
+ */
+export class PredicatePattern implements Matcher {
+  readonly #pattern: PredicatePatternType;
+
+  private constructor(pattern: PredicatePatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new PredicatePattern that matches any predicate.
+   */
+  static any(): PredicatePattern {
+    return new PredicatePattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new PredicatePattern that matches predicates matching the given pattern.
+   */
+  static pattern(pattern: Pattern): PredicatePattern {
+    return new PredicatePattern({ type: "Pattern", pattern });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): PredicatePatternType {
+    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 predicate = haystack.asPredicate?.();
+
+    if (predicate === undefined) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    let paths: Path[];
+
+    switch (this.#pattern.type) {
+      case "Any":
+        paths = [[predicate]];
+        break;
+      case "Pattern": {
+        const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+        if (innerMatcher.matches(predicate)) {
+          paths = [[predicate]];
+        } 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 (createStructurePredicatePattern === undefined) {
+      throw new Error("PredicatePattern factory not registered");
+    }
+    const idx = literals.length;
+    literals.push(createStructurePredicatePattern(this));
+    code.push({ type: "MatchStructure", literalIndex: idx });
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "pred";
+      case "Pattern":
+        return `pred(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: PredicatePattern): 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;
+  }
+}

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

@@ -0,0 +1,152 @@
+/**
+ * @bcts/envelope-pattern - Subject pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust subject_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/subject-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 (used for late binding)
+export let createStructureSubjectPattern: ((pattern: SubjectPattern) => Pattern) | undefined;
+
+export function registerSubjectPatternFactory(factory: (pattern: SubjectPattern) => Pattern): void {
+  createStructureSubjectPattern = factory;
+}
+
+/**
+ * Pattern type for subject pattern matching.
+ *
+ * Corresponds to the Rust `SubjectPattern` enum in subject_pattern.rs
+ */
+export type SubjectPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Pattern"; readonly pattern: Pattern };
+
+/**
+ * Pattern for matching subjects in envelopes.
+ *
+ * Corresponds to the Rust `SubjectPattern` enum in subject_pattern.rs
+ */
+export class SubjectPattern implements Matcher {
+  readonly #pattern: SubjectPatternType;
+
+  private constructor(pattern: SubjectPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new SubjectPattern that matches any subject.
+   */
+  static any(): SubjectPattern {
+    return new SubjectPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new SubjectPattern that matches subjects matching the given pattern.
+   */
+  static pattern(pattern: Pattern): SubjectPattern {
+    return new SubjectPattern({ type: "Pattern", pattern });
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): SubjectPatternType {
+    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 subject = haystack.subject();
+    let paths: Path[];
+
+    switch (this.#pattern.type) {
+      case "Any":
+        paths = [[subject]];
+        break;
+      case "Pattern": {
+        const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+        if (innerMatcher.matches(subject)) {
+          paths = [[subject]];
+        } 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 {
+    switch (this.#pattern.type) {
+      case "Any":
+        code.push({ type: "NavigateSubject" });
+        break;
+      case "Pattern":
+        // Navigate to the subject first
+        code.push({ type: "NavigateSubject" });
+        // Save the path and run the inner pattern relative to the subject
+        code.push({ type: "ExtendTraversal" });
+        (this.#pattern.pattern as unknown as Matcher).compile(code, literals, captures);
+        code.push({ type: "CombineTraversal" });
+        break;
+    }
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "subj";
+      case "Pattern":
+        return `subj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: SubjectPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    if (this.#pattern.type === "Any") {
+      return true;
+    }
+    // For Pattern type, compare the inner patterns
+    const thisPattern = (this.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const otherPattern = (other.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    return thisPattern === otherPattern; // Reference equality for now
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return this.#pattern.type === "Any" ? 0 : 1;
+  }
+}

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

@@ -0,0 +1,195 @@
+/**
+ * @bcts/envelope-pattern - Wrapped pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust wrapped_pattern.rs
+ *
+ * @module envelope-pattern/pattern/structure/wrapped-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import type { Instr, Axis } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory
+let createStructureWrappedPattern: ((pattern: WrappedPattern) => Pattern) | undefined;
+
+export function registerWrappedPatternFactory(factory: (pattern: WrappedPattern) => Pattern): void {
+  createStructureWrappedPattern = factory;
+}
+
+/**
+ * Pattern type for wrapped pattern matching.
+ *
+ * Corresponds to the Rust `WrappedPattern` enum in wrapped_pattern.rs
+ */
+export type WrappedPatternType =
+  | { readonly type: "Any" }
+  | { readonly type: "Unwrap"; readonly pattern: Pattern };
+
+/**
+ * Represents patterns for matching wrapped envelopes.
+ *
+ * Corresponds to the Rust `WrappedPattern` enum in wrapped_pattern.rs
+ */
+export class WrappedPattern implements Matcher {
+  readonly #pattern: WrappedPatternType;
+
+  private constructor(pattern: WrappedPatternType) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new WrappedPattern that matches any wrapped envelope without descending.
+   */
+  static new(): WrappedPattern {
+    return new WrappedPattern({ type: "Any" });
+  }
+
+  /**
+   * Creates a new WrappedPattern that matches a wrapped envelope and also matches
+   * on its unwrapped content.
+   */
+  static unwrapMatching(pattern: Pattern): WrappedPattern {
+    return new WrappedPattern({ type: "Unwrap", pattern });
+  }
+
+  /**
+   * Creates a new WrappedPattern that matches any wrapped envelope and descends into it.
+   * Note: This requires Pattern.any() to be available, so it's set up during registration.
+   */
+  static unwrap(): WrappedPattern {
+    // This will be filled in when Pattern.any() is available
+    // For now, create a placeholder that will be replaced
+    return new WrappedPattern({ type: "Any" }); // Will be overwritten
+  }
+
+  /**
+   * Gets the pattern type.
+   */
+  get patternType(): WrappedPatternType {
+    return this.#pattern;
+  }
+
+  /**
+   * Gets the inner pattern if this is an Unwrap type, undefined otherwise.
+   */
+  innerPattern(): Pattern | undefined {
+    return this.#pattern.type === "Unwrap" ? this.#pattern.pattern : undefined;
+  }
+
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    const subject = haystack.subject();
+
+    if (!subject.isWrapped()) {
+      return [[], new Map<string, Path[]>()];
+    }
+
+    let paths: Path[];
+
+    switch (this.#pattern.type) {
+      case "Any":
+        // Just match the wrapped envelope itself, don't descend
+        paths = [[haystack]];
+        break;
+      case "Unwrap": {
+        // Match the content of the wrapped envelope
+        const unwrapped = subject.tryUnwrap?.();
+        if (unwrapped !== undefined) {
+          const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+          const innerPaths = innerMatcher.paths(unwrapped);
+          paths = innerPaths.map((path) => {
+            // Add the current envelope to the path
+            return [haystack, ...path];
+          });
+        } 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 (createStructureWrappedPattern === undefined) {
+      throw new Error("WrappedPattern factory not registered");
+    }
+
+    switch (this.#pattern.type) {
+      case "Any": {
+        // Just match the wrapped envelope itself, don't descend
+        const idx = literals.length;
+        literals.push(createStructureWrappedPattern(this));
+        code.push({ type: "MatchStructure", literalIndex: idx });
+        break;
+      }
+      case "Unwrap": {
+        // First match that it's wrapped
+        const idx = literals.length;
+        literals.push(createStructureWrappedPattern(WrappedPattern.new()));
+        code.push({ type: "MatchStructure", literalIndex: idx });
+
+        // Then move into inner envelope
+        const axis: Axis = "Wrapped";
+        code.push({ type: "PushAxis", axis });
+
+        // Then match the pattern
+        const innerMatcher = this.#pattern.pattern as unknown as Matcher;
+        innerMatcher.compile(code, literals, captures);
+        break;
+      }
+    }
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    switch (this.#pattern.type) {
+      case "Any":
+        return "wrapped";
+      case "Unwrap": {
+        // Check if it's the "any" pattern by string comparison
+        const patternStr = (this.#pattern.pattern as unknown as { toString(): string }).toString();
+        if (patternStr === "*") {
+          return "unwrap";
+        }
+        return `unwrap(${patternStr})`;
+      }
+    }
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: WrappedPattern): boolean {
+    if (this.#pattern.type !== other.#pattern.type) {
+      return false;
+    }
+    if (this.#pattern.type === "Any") {
+      return true;
+    }
+    const thisPattern = (this.#pattern as { type: "Unwrap"; pattern: Pattern }).pattern;
+    const otherPattern = (other.#pattern as { type: "Unwrap"; pattern: Pattern }).pattern;
+    return thisPattern === otherPattern;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return this.#pattern.type === "Any" ? 0 : 1;
+  }
+}