@bcts/dcbor-pattern 1.0.0-alpha.11

package/src/pattern/meta/index.ts

@@ -0,0 +1,168 @@
+/**
+ * Meta patterns for dCBOR pattern matching.
+ *
+ * @module pattern/meta
+ */
+
+export * from "./any-pattern";
+export * from "./and-pattern";
+export * from "./or-pattern";
+export * from "./not-pattern";
+export * from "./repeat-pattern";
+export * from "./capture-pattern";
+export * from "./search-pattern";
+export * from "./sequence-pattern";
+
+import type { Cbor } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+
+import { type AnyPattern, anyPatternPaths, anyPatternDisplay } from "./any-pattern";
+import { type AndPattern, andPatternPaths, andPatternDisplay } from "./and-pattern";
+import { type OrPattern, orPatternPaths, orPatternDisplay } from "./or-pattern";
+import { type NotPattern, notPatternPaths, notPatternDisplay } from "./not-pattern";
+import { type RepeatPattern, repeatPatternPaths, repeatPatternDisplay } from "./repeat-pattern";
+import { type CapturePattern, capturePatternPaths, capturePatternDisplay } from "./capture-pattern";
+import { type SearchPattern, searchPatternPaths, searchPatternDisplay } from "./search-pattern";
+import {
+  type SequencePattern,
+  sequencePatternPaths,
+  sequencePatternDisplay,
+} from "./sequence-pattern";
+
+/**
+ * Union of all meta pattern types.
+ */
+export type MetaPattern =
+  | { readonly type: "Any"; readonly pattern: AnyPattern }
+  | { readonly type: "And"; readonly pattern: AndPattern }
+  | { readonly type: "Or"; readonly pattern: OrPattern }
+  | { readonly type: "Not"; readonly pattern: NotPattern }
+  | { readonly type: "Repeat"; readonly pattern: RepeatPattern }
+  | { readonly type: "Capture"; readonly pattern: CapturePattern }
+  | { readonly type: "Search"; readonly pattern: SearchPattern }
+  | { readonly type: "Sequence"; readonly pattern: SequencePattern };
+
+/**
+ * Returns paths to matching values for a MetaPattern.
+ */
+export const metaPatternPaths = (pattern: MetaPattern, haystack: Cbor): Path[] => {
+  switch (pattern.type) {
+    case "Any":
+      return anyPatternPaths(pattern.pattern, haystack);
+    case "And":
+      return andPatternPaths(pattern.pattern, haystack);
+    case "Or":
+      return orPatternPaths(pattern.pattern, haystack);
+    case "Not":
+      return notPatternPaths(pattern.pattern, haystack);
+    case "Repeat":
+      return repeatPatternPaths(pattern.pattern, haystack);
+    case "Capture":
+      return capturePatternPaths(pattern.pattern, haystack);
+    case "Search":
+      return searchPatternPaths(pattern.pattern, haystack);
+    case "Sequence":
+      return sequencePatternPaths(pattern.pattern, haystack);
+  }
+};
+
+/**
+ * Tests if a CBOR value matches a MetaPattern.
+ */
+export const metaPatternMatches = (pattern: MetaPattern, haystack: Cbor): boolean => {
+  return metaPatternPaths(pattern, haystack).length > 0;
+};
+
+/**
+ * Formats a MetaPattern as a string.
+ */
+export const metaPatternDisplay = (
+  pattern: MetaPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  switch (pattern.type) {
+    case "Any":
+      return anyPatternDisplay(pattern.pattern);
+    case "And":
+      return andPatternDisplay(pattern.pattern, patternDisplay);
+    case "Or":
+      return orPatternDisplay(pattern.pattern, patternDisplay);
+    case "Not":
+      return notPatternDisplay(pattern.pattern, patternDisplay);
+    case "Repeat":
+      return repeatPatternDisplay(pattern.pattern, patternDisplay);
+    case "Capture":
+      return capturePatternDisplay(pattern.pattern, patternDisplay);
+    case "Search":
+      return searchPatternDisplay(pattern.pattern, patternDisplay);
+    case "Sequence":
+      return sequencePatternDisplay(pattern.pattern, patternDisplay);
+  }
+};
+
+// Convenience constructors for MetaPattern
+
+/**
+ * Creates an Any MetaPattern.
+ */
+export const metaAny = (pattern: AnyPattern): MetaPattern => ({
+  type: "Any",
+  pattern,
+});
+
+/**
+ * Creates an And MetaPattern.
+ */
+export const metaAnd = (pattern: AndPattern): MetaPattern => ({
+  type: "And",
+  pattern,
+});
+
+/**
+ * Creates an Or MetaPattern.
+ */
+export const metaOr = (pattern: OrPattern): MetaPattern => ({
+  type: "Or",
+  pattern,
+});
+
+/**
+ * Creates a Not MetaPattern.
+ */
+export const metaNot = (pattern: NotPattern): MetaPattern => ({
+  type: "Not",
+  pattern,
+});
+
+/**
+ * Creates a Repeat MetaPattern.
+ */
+export const metaRepeat = (pattern: RepeatPattern): MetaPattern => ({
+  type: "Repeat",
+  pattern,
+});
+
+/**
+ * Creates a Capture MetaPattern.
+ */
+export const metaCapture = (pattern: CapturePattern): MetaPattern => ({
+  type: "Capture",
+  pattern,
+});
+
+/**
+ * Creates a Search MetaPattern.
+ */
+export const metaSearch = (pattern: SearchPattern): MetaPattern => ({
+  type: "Search",
+  pattern,
+});
+
+/**
+ * Creates a Sequence MetaPattern.
+ */
+export const metaSequence = (pattern: SequencePattern): MetaPattern => ({
+  type: "Sequence",
+  pattern,
+});

package/src/pattern/meta/not-pattern.ts

@@ -0,0 +1,70 @@
+/**
+ * Not pattern for dCBOR pattern matching.
+ * Matches if the inner pattern does NOT match.
+ *
+ * @module pattern/meta/not-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+import { matchPattern } from "../match-registry";
+
+/**
+ * A pattern that matches if the inner pattern does NOT match.
+ */
+export interface NotPattern {
+  readonly variant: "Not";
+  readonly pattern: Pattern;
+}
+
+/**
+ * Creates a NotPattern with the given inner pattern.
+ */
+export const notPattern = (pattern: Pattern): NotPattern => ({
+  variant: "Not",
+  pattern,
+});
+
+/**
+ * Tests if a CBOR value matches this not pattern.
+ * Returns true if the inner pattern does NOT match.
+ */
+export const notPatternMatches = (pattern: NotPattern, haystack: Cbor): boolean => {
+  return !matchPattern(pattern.pattern, haystack);
+};
+
+/**
+ * Returns paths to matching values.
+ */
+export const notPatternPaths = (pattern: NotPattern, haystack: Cbor): Path[] => {
+  if (notPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Check if a pattern is complex for display purposes.
+ * Complex patterns need parentheses when inside a NOT pattern.
+ */
+const isComplex = (pattern: Pattern): boolean => {
+  if (pattern.kind === "Meta") {
+    // AND, OR, NOT, Sequence are complex
+    return ["And", "Or", "Not", "Sequence"].includes(pattern.pattern.type);
+  }
+  return false;
+};
+
+/**
+ * Formats a NotPattern as a string.
+ */
+export const notPatternDisplay = (
+  pattern: NotPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  if (isComplex(pattern.pattern)) {
+    return `!(${patternDisplay(pattern.pattern)})`;
+  }
+  return `!${patternDisplay(pattern.pattern)}`;
+};

package/src/pattern/meta/or-pattern.ts

@@ -0,0 +1,56 @@
+/**
+ * Or pattern for dCBOR pattern matching.
+ * Matches if any contained pattern matches.
+ *
+ * @module pattern/meta/or-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+import { matchPattern } from "../match-registry";
+
+/**
+ * A pattern that matches if any contained pattern matches.
+ */
+export interface OrPattern {
+  readonly variant: "Or";
+  readonly patterns: Pattern[];
+}
+
+/**
+ * Creates an OrPattern with the given patterns.
+ */
+export const orPattern = (patterns: Pattern[]): OrPattern => ({
+  variant: "Or",
+  patterns,
+});
+
+/**
+ * Tests if a CBOR value matches this or pattern.
+ * At least one pattern must match.
+ */
+export const orPatternMatches = (pattern: OrPattern, haystack: Cbor): boolean => {
+  return pattern.patterns.some((p: Pattern) => matchPattern(p, haystack));
+};
+
+/**
+ * Returns paths to matching values.
+ */
+export const orPatternPaths = (pattern: OrPattern, haystack: Cbor): Path[] => {
+  if (orPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats an OrPattern as a string.
+ */
+export const orPatternDisplay = (
+  pattern: OrPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  const parts = pattern.patterns.map(patternDisplay);
+  return parts.join(" | ");
+};

package/src/pattern/meta/repeat-pattern.ts

@@ -0,0 +1,117 @@
+/**
+ * Repeat pattern for dCBOR pattern matching.
+ * Matches with repetition based on a quantifier.
+ *
+ * @module pattern/meta/repeat-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+import { Quantifier } from "../../quantifier";
+
+/**
+ * A pattern that matches with repetition.
+ */
+export interface RepeatPattern {
+  readonly variant: "Repeat";
+  readonly pattern: Pattern;
+  readonly quantifier: Quantifier;
+}
+
+/**
+ * Creates a RepeatPattern with the given pattern and quantifier.
+ */
+export const repeatPattern = (pattern: Pattern, quantifier: Quantifier): RepeatPattern => ({
+  variant: "Repeat",
+  pattern,
+  quantifier,
+});
+
+/**
+ * Creates a RepeatPattern that matches zero or more times (greedy).
+ */
+export const repeatZeroOrMore = (pattern: Pattern): RepeatPattern => ({
+  variant: "Repeat",
+  pattern,
+  quantifier: Quantifier.zeroOrMore(),
+});
+
+/**
+ * Creates a RepeatPattern that matches one or more times (greedy).
+ */
+export const repeatOneOrMore = (pattern: Pattern): RepeatPattern => ({
+  variant: "Repeat",
+  pattern,
+  quantifier: Quantifier.oneOrMore(),
+});
+
+/**
+ * Creates a RepeatPattern that matches zero or one time (greedy).
+ */
+export const repeatOptional = (pattern: Pattern): RepeatPattern => ({
+  variant: "Repeat",
+  pattern,
+  quantifier: Quantifier.zeroOrOne(),
+});
+
+/**
+ * Creates a RepeatPattern that matches exactly n times.
+ */
+export const repeatExact = (pattern: Pattern, n: number): RepeatPattern => ({
+  variant: "Repeat",
+  pattern,
+  quantifier: Quantifier.exactly(n),
+});
+
+/**
+ * Creates a RepeatPattern that matches between min and max times.
+ */
+export const repeatRange = (pattern: Pattern, min: number, max?: number): RepeatPattern => ({
+  variant: "Repeat",
+  pattern,
+  quantifier: max !== undefined ? Quantifier.between(min, max) : Quantifier.atLeast(min),
+});
+
+import { matchPattern } from "../match-registry";
+
+/**
+ * Tests if a CBOR value matches this repeat pattern.
+ * Note: This is a simplified implementation. Complex matching
+ * will be implemented with the VM.
+ */
+export const repeatPatternMatches = (pattern: RepeatPattern, haystack: Cbor): boolean => {
+  // Simple case: check if the inner pattern matches at least once
+  // and the quantifier allows it
+  const innerMatches = matchPattern(pattern.pattern, haystack);
+  const min = pattern.quantifier.min();
+  const max = pattern.quantifier.max();
+
+  if (innerMatches) {
+    // If pattern matches once, check if 1 is in valid range
+    return min <= 1 && (max === undefined || max >= 1);
+  }
+  // If pattern doesn't match, only valid if min is 0
+  return min === 0;
+};
+
+/**
+ * Returns paths to matching values.
+ */
+export const repeatPatternPaths = (pattern: RepeatPattern, haystack: Cbor): Path[] => {
+  if (repeatPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a RepeatPattern as a string.
+ * Always wraps the inner pattern in parentheses to match Rust behavior.
+ */
+export const repeatPatternDisplay = (
+  pattern: RepeatPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  return `(${patternDisplay(pattern.pattern)})${pattern.quantifier.toString()}`;
+};

package/src/pattern/meta/search-pattern.ts

@@ -0,0 +1,298 @@
+/**
+ * Search pattern for dCBOR pattern matching.
+ * Searches the entire CBOR tree for matches.
+ *
+ * @module pattern/meta/search-pattern
+ */
+
+import type { Cbor, CborInput } from "@bcts/dcbor";
+import {
+  isArray,
+  isMap,
+  isTagged,
+  arrayLength,
+  arrayItem,
+  mapKeys,
+  mapValue,
+  tagContent,
+  cbor,
+} from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+import { matchPattern } from "../match-registry";
+
+/**
+ * A pattern that searches the entire CBOR tree for matches.
+ */
+export interface SearchPattern {
+  readonly variant: "Search";
+  readonly pattern: Pattern;
+}
+
+/**
+ * Creates a SearchPattern with the given inner pattern.
+ */
+export const searchPattern = (pattern: Pattern): SearchPattern => ({
+  variant: "Search",
+  pattern,
+});
+
+/**
+ * Recursively searches the CBOR tree and collects all matching paths.
+ */
+const searchRecursive = (
+  pattern: Pattern,
+  haystack: Cbor,
+  currentPath: Cbor[],
+  results: Path[],
+): void => {
+  // Check if current node matches
+  if (matchPattern(pattern, haystack)) {
+    results.push([...currentPath, haystack]);
+  }
+
+  // Recursively search children
+  if (isArray(haystack)) {
+    const len = arrayLength(haystack);
+    if (len !== undefined) {
+      for (let i = 0; i < len; i++) {
+        const item = arrayItem(haystack, i);
+        if (item !== undefined) {
+          searchRecursive(pattern, item, [...currentPath, haystack], results);
+        }
+      }
+    }
+  } else if (isMap(haystack)) {
+    const keys = mapKeys(haystack);
+    if (keys !== undefined) {
+      for (const key of keys) {
+        // Search in keys
+        searchRecursive(pattern, key, [...currentPath, haystack], results);
+        // Search in values
+        const rawValue = mapValue(haystack, key);
+        if (rawValue !== undefined && rawValue !== null) {
+          // Wrap raw JavaScript value in CBOR if needed
+          const value = (rawValue as Cbor)?.isCbor
+            ? (rawValue as Cbor)
+            : cbor(rawValue as CborInput);
+          searchRecursive(pattern, value, [...currentPath, haystack], results);
+        }
+      }
+    }
+  } else if (isTagged(haystack)) {
+    const content = tagContent(haystack);
+    if (content !== undefined) {
+      searchRecursive(pattern, content, [...currentPath, haystack], results);
+    }
+  }
+};
+
+/**
+ * Tests if a CBOR value matches this search pattern.
+ * Returns true if any node in the tree matches.
+ */
+export const searchPatternMatches = (pattern: SearchPattern, haystack: Cbor): boolean => {
+  const paths = searchPatternPaths(pattern, haystack);
+  return paths.length > 0;
+};
+
+/**
+ * Returns paths to all matching values in the tree.
+ */
+export const searchPatternPaths = (pattern: SearchPattern, haystack: Cbor): Path[] => {
+  const results: Path[] = [];
+  searchRecursive(pattern.pattern, haystack, [], results);
+  return results;
+};
+
+/**
+ * Result type for paths with captures from search operations.
+ */
+export interface SearchWithCaptures {
+  readonly paths: Path[];
+  readonly captures: Map<string, Path[]>;
+}
+
+/**
+ * Recursively searches the CBOR tree, collecting paths and captures.
+ */
+const searchRecursiveWithCaptures = (
+  pattern: Pattern,
+  haystack: Cbor,
+  currentPath: Cbor[],
+  results: Path[],
+  captures: Map<string, Path[]>,
+  collectCapture: (p: Pattern, h: Cbor, path: Cbor[]) => void,
+): void => {
+  // Check if current node matches
+  if (matchPattern(pattern, haystack)) {
+    const matchPath = [...currentPath, haystack];
+    results.push(matchPath);
+    // Collect captures for this match
+    collectCapture(pattern, haystack, matchPath);
+  }
+
+  // Recursively search children
+  if (isArray(haystack)) {
+    const len = arrayLength(haystack);
+    if (len !== undefined) {
+      for (let i = 0; i < len; i++) {
+        const item = arrayItem(haystack, i);
+        if (item !== undefined) {
+          searchRecursiveWithCaptures(
+            pattern,
+            item,
+            [...currentPath, haystack],
+            results,
+            captures,
+            collectCapture,
+          );
+        }
+      }
+    }
+  } else if (isMap(haystack)) {
+    const keys = mapKeys(haystack);
+    if (keys !== undefined) {
+      for (const key of keys) {
+        // Search in keys
+        searchRecursiveWithCaptures(
+          pattern,
+          key,
+          [...currentPath, haystack],
+          results,
+          captures,
+          collectCapture,
+        );
+        // Search in values
+        const rawValue = mapValue(haystack, key);
+        if (rawValue !== undefined && rawValue !== null) {
+          // Wrap raw JavaScript value in CBOR if needed
+          const value = (rawValue as Cbor)?.isCbor
+            ? (rawValue as Cbor)
+            : cbor(rawValue as CborInput);
+          searchRecursiveWithCaptures(
+            pattern,
+            value,
+            [...currentPath, haystack],
+            results,
+            captures,
+            collectCapture,
+          );
+        }
+      }
+    }
+  } else if (isTagged(haystack)) {
+    const content = tagContent(haystack);
+    if (content !== undefined) {
+      searchRecursiveWithCaptures(
+        pattern,
+        content,
+        [...currentPath, haystack],
+        results,
+        captures,
+        collectCapture,
+      );
+    }
+  }
+};
+
+/**
+ * Extract capture from a pattern at a given match location.
+ * Recursively searches for all capture patterns.
+ */
+const extractCaptures = (
+  pattern: Pattern,
+  matchPath: Cbor[],
+  captures: Map<string, Path[]>,
+): void => {
+  if (pattern.kind === "Meta") {
+    switch (pattern.pattern.type) {
+      case "Capture": {
+        const captureName = pattern.pattern.pattern.name;
+        const existing = captures.get(captureName) ?? [];
+        existing.push(matchPath);
+        captures.set(captureName, existing);
+        // Also extract from inner pattern
+        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);
+        break;
+      }
+      case "And":
+        for (const p of pattern.pattern.pattern.patterns) {
+          extractCaptures(p, matchPath, captures);
+        }
+        break;
+      case "Or":
+        for (const p of pattern.pattern.pattern.patterns) {
+          extractCaptures(p, matchPath, captures);
+        }
+        break;
+      case "Sequence":
+        for (const p of pattern.pattern.pattern.patterns) {
+          extractCaptures(p, matchPath, captures);
+        }
+        break;
+      case "Not":
+        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);
+        break;
+      case "Repeat":
+        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);
+        break;
+      case "Search":
+        extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);
+        break;
+      case "Any":
+        // No captures
+        break;
+    }
+  } else if (pattern.kind === "Structure") {
+    switch (pattern.pattern.type) {
+      case "Array":
+        if (pattern.pattern.pattern.variant === "Elements") {
+          extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);
+        }
+        break;
+      case "Map":
+        if (pattern.pattern.pattern.variant === "Constraints") {
+          for (const [keyPattern, valuePattern] of pattern.pattern.pattern.constraints) {
+            extractCaptures(keyPattern, matchPath, captures);
+            extractCaptures(valuePattern, matchPath, captures);
+          }
+        }
+        break;
+      case "Tagged":
+        if (pattern.pattern.pattern.variant !== "Any") {
+          extractCaptures(pattern.pattern.pattern.pattern, matchPath, captures);
+        }
+        break;
+    }
+  }
+};
+
+/**
+ * Returns paths with captures for all matching values in the tree.
+ */
+export const searchPatternPathsWithCaptures = (
+  pattern: SearchPattern,
+  haystack: Cbor,
+): SearchWithCaptures => {
+  const results: Path[] = [];
+  const captures = new Map<string, Path[]>();
+
+  const collectCapture = (p: Pattern, _h: Cbor, path: Cbor[]): void => {
+    extractCaptures(p, path, captures);
+  };
+
+  searchRecursiveWithCaptures(pattern.pattern, haystack, [], results, captures, collectCapture);
+
+  return { paths: results, captures };
+};
+
+/**
+ * Formats a SearchPattern as a string.
+ */
+export const searchPatternDisplay = (
+  pattern: SearchPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  return `search(${patternDisplay(pattern.pattern)})`;
+};