@bcts/dcbor-pattern 1.0.0-alpha.11

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

@@ -0,0 +1,255 @@
+/**
+ * Map pattern for dCBOR pattern matching.
+ *
+ * @module pattern/structure/map-pattern
+ */
+
+import type { Cbor, CborInput } from "@bcts/dcbor";
+import { isMap, mapSize, mapKeys, mapValue, cbor } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+import { Interval } from "../../interval";
+import { matchPattern } from "../match-registry";
+
+/**
+ * Pattern for matching CBOR map structures.
+ */
+export type MapPattern =
+  | { readonly variant: "Any" }
+  | {
+      readonly variant: "Constraints";
+      readonly constraints: [Pattern, Pattern][];
+    }
+  | { readonly variant: "Length"; readonly length: Interval };
+
+/**
+ * Creates a MapPattern that matches any map.
+ */
+export const mapPatternAny = (): MapPattern => ({ variant: "Any" });
+
+/**
+ * Creates a MapPattern that matches maps with key-value constraints.
+ */
+export const mapPatternWithConstraints = (constraints: [Pattern, Pattern][]): MapPattern => ({
+  variant: "Constraints",
+  constraints,
+});
+
+/**
+ * Creates a MapPattern that matches maps with a specific number of entries.
+ */
+export const mapPatternWithLength = (length: number): MapPattern => ({
+  variant: "Length",
+  length: Interval.exactly(length),
+});
+
+/**
+ * Creates a MapPattern that matches maps with length in a range.
+ */
+export const mapPatternWithLengthRange = (min: number, max?: number): MapPattern => ({
+  variant: "Length",
+  length: max !== undefined ? Interval.from(min, max) : Interval.atLeast(min),
+});
+
+/**
+ * Creates a MapPattern that matches maps with length in an interval.
+ */
+export const mapPatternWithLengthInterval = (interval: Interval): MapPattern => ({
+  variant: "Length",
+  length: interval,
+});
+
+/**
+ * Tests if a CBOR value matches this map pattern.
+ */
+export const mapPatternMatches = (pattern: MapPattern, haystack: Cbor): boolean => {
+  if (!isMap(haystack)) {
+    return false;
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Constraints": {
+      const keys = mapKeys(haystack);
+      if (keys === undefined) {
+        return false;
+      }
+      // All constraints must be satisfied
+      for (const [keyPattern, valuePattern] of pattern.constraints) {
+        let foundMatch = false;
+        for (const key of keys) {
+          if (matchPattern(keyPattern, key)) {
+            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);
+              if (matchPattern(valuePattern, value)) {
+                foundMatch = true;
+                break;
+              }
+            }
+          }
+        }
+        if (!foundMatch) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case "Length": {
+      const size = mapSize(haystack);
+      return size !== undefined && pattern.length.contains(size);
+    }
+  }
+};
+
+/**
+ * Returns paths to matching map values.
+ */
+export const mapPatternPaths = (pattern: MapPattern, haystack: Cbor): Path[] => {
+  if (mapPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Helper to build a map context path (map -> element).
+ */
+const buildMapContextPath = (mapCbor: Cbor, element: Cbor): Path => {
+  return [mapCbor, element];
+};
+
+/**
+ * Collects captures from a pattern by checking if it's a capture pattern.
+ */
+const collectCapturesFromPattern = (
+  pattern: Pattern,
+  matchedValue: Cbor,
+  mapContext: Cbor,
+  captures: Map<string, Path[]>,
+): void => {
+  if (pattern.kind === "Meta" && pattern.pattern.type === "Capture") {
+    const captureName = pattern.pattern.pattern.name;
+    const contextPath = buildMapContextPath(mapContext, matchedValue);
+    const existing = captures.get(captureName) ?? [];
+    existing.push(contextPath);
+    captures.set(captureName, existing);
+
+    // Also collect from inner pattern
+    collectCapturesFromPattern(pattern.pattern.pattern.pattern, matchedValue, mapContext, captures);
+  }
+};
+
+/**
+ * Returns paths with captures for map patterns.
+ */
+export const mapPatternPathsWithCaptures = (
+  pattern: MapPattern,
+  haystack: Cbor,
+): [Path[], Map<string, Path[]>] => {
+  if (!isMap(haystack)) {
+    return [[], new Map<string, Path[]>()];
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+    case "Length":
+      return [mapPatternPaths(pattern, haystack), new Map<string, Path[]>()];
+
+    case "Constraints": {
+      const keys = mapKeys(haystack);
+      if (keys === undefined) {
+        return [[], new Map<string, Path[]>()];
+      }
+
+      const captures = new Map<string, Path[]>();
+
+      // For each constraint, find the matching key-value pair and collect captures
+      for (const [keyPattern, valuePattern] of pattern.constraints) {
+        for (const key of keys) {
+          if (matchPattern(keyPattern, key)) {
+            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);
+              if (matchPattern(valuePattern, value)) {
+                // Collect captures from key pattern
+                collectCapturesFromPattern(keyPattern, key, haystack, captures);
+                // Collect captures from value pattern
+                collectCapturesFromPattern(valuePattern, value, haystack, captures);
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      // If pattern matches, return the map path with captures
+      if (mapPatternMatches(pattern, haystack)) {
+        return [[[haystack]], captures];
+      }
+      return [[], new Map<string, Path[]>()];
+    }
+  }
+};
+
+/**
+ * Formats a MapPattern as a string.
+ */
+export const mapPatternDisplay = (
+  pattern: MapPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "map";
+    case "Constraints": {
+      const parts = pattern.constraints.map(
+        ([k, v]) => `${patternDisplay(k)}: ${patternDisplay(v)}`,
+      );
+      return `{${parts.join(", ")}}`;
+    }
+    case "Length":
+      return `{${pattern.length.toString()}}`;
+  }
+};
+
+/**
+ * Compares two MapPatterns for equality.
+ */
+export const mapPatternEquals = (
+  a: MapPattern,
+  b: MapPattern,
+  patternEquals: (p1: Pattern, p2: Pattern) => boolean,
+): boolean => {
+  if (a.variant !== b.variant) {
+    return false;
+  }
+  switch (a.variant) {
+    case "Any":
+      return true;
+    case "Constraints": {
+      const bConstraints = (b as typeof a).constraints;
+      if (a.constraints.length !== bConstraints.length) {
+        return false;
+      }
+      for (let i = 0; i < a.constraints.length; i++) {
+        if (
+          !patternEquals(a.constraints[i][0], bConstraints[i][0]) ||
+          !patternEquals(a.constraints[i][1], bConstraints[i][1])
+        ) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case "Length":
+      return a.length.equals((b as typeof a).length);
+  }
+};

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

@@ -0,0 +1,190 @@
+/**
+ * Tagged pattern for dCBOR pattern matching.
+ *
+ * @module pattern/structure/tagged-pattern
+ */
+
+import type { Cbor, Tag } from "@bcts/dcbor";
+import { isTagged, tagValue, tagContent } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import type { Pattern } from "../index";
+import { matchPattern, getPatternPathsWithCapturesDirect } from "../match-registry";
+
+/**
+ * Pattern for matching CBOR tagged value structures.
+ */
+export type TaggedPattern =
+  | { readonly variant: "Any" }
+  | {
+      readonly variant: "Tag";
+      readonly tag: Tag;
+      readonly pattern: Pattern;
+    }
+  | {
+      readonly variant: "Name";
+      readonly name: string;
+      readonly pattern: Pattern;
+    }
+  | {
+      readonly variant: "Regex";
+      readonly regex: RegExp;
+      readonly pattern: Pattern;
+    };
+
+/**
+ * Creates a TaggedPattern that matches any tagged value.
+ */
+export const taggedPatternAny = (): TaggedPattern => ({ variant: "Any" });
+
+/**
+ * Creates a TaggedPattern that matches tagged values with specific tag and content.
+ */
+export const taggedPatternWithTag = (tag: Tag, pattern: Pattern): TaggedPattern => ({
+  variant: "Tag",
+  tag,
+  pattern,
+});
+
+/**
+ * Creates a TaggedPattern that matches tagged values with a tag having the given name.
+ */
+export const taggedPatternWithName = (name: string, pattern: Pattern): TaggedPattern => ({
+  variant: "Name",
+  name,
+  pattern,
+});
+
+/**
+ * Creates a TaggedPattern that matches tagged values with a tag name matching the regex.
+ */
+export const taggedPatternWithRegex = (regex: RegExp, pattern: Pattern): TaggedPattern => ({
+  variant: "Regex",
+  regex,
+  pattern,
+});
+
+/**
+ * Tests if a CBOR value matches this tagged pattern.
+ */
+export const taggedPatternMatches = (pattern: TaggedPattern, haystack: Cbor): boolean => {
+  if (!isTagged(haystack)) {
+    return false;
+  }
+
+  const tag = tagValue(haystack);
+  const content = tagContent(haystack);
+
+  if (content === undefined) {
+    return false;
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Tag":
+      return tag === pattern.tag.value && matchPattern(pattern.pattern, content);
+    case "Name": {
+      // Get tag name from global tags store
+      // For now, compare the tag value as string
+      const tagName = String(tag);
+      return tagName === pattern.name && matchPattern(pattern.pattern, content);
+    }
+    case "Regex": {
+      const tagName = String(tag);
+      return pattern.regex.test(tagName) && matchPattern(pattern.pattern, content);
+    }
+  }
+};
+
+/**
+ * Returns paths to matching tagged values.
+ */
+export const taggedPatternPaths = (pattern: TaggedPattern, haystack: Cbor): Path[] => {
+  if (taggedPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Returns paths with captures for a tagged pattern.
+ * Collects captures from inner patterns for Tag variant.
+ */
+export const taggedPatternPathsWithCaptures = (
+  pattern: TaggedPattern,
+  haystack: Cbor,
+): [Path[], Map<string, Path[]>] => {
+  if (!isTagged(haystack)) {
+    return [[], new Map<string, Path[]>()];
+  }
+
+  const tag = tagValue(haystack);
+  const content = tagContent(haystack);
+
+  if (content === undefined) {
+    return [[], new Map<string, Path[]>()];
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+      // Matches any tagged value, no captures
+      return [[[haystack]], new Map<string, Path[]>()];
+
+    case "Tag": {
+      if (tag !== pattern.tag.value) {
+        return [[], new Map<string, Path[]>()];
+      }
+      // Get paths and captures from inner pattern
+      const innerResult = getPatternPathsWithCapturesDirect(pattern.pattern, content);
+      if (innerResult.paths.length === 0) {
+        return [[], innerResult.captures];
+      }
+
+      // Build paths that include the tagged value as root
+      const taggedPaths: Path[] = innerResult.paths.map((contentPath: Path) => {
+        const path: Cbor[] = [haystack];
+        // Skip the content's root in the path
+        if (contentPath.length > 1) {
+          path.push(...contentPath.slice(1));
+        }
+        return path;
+      });
+
+      // Update captures to include tagged value as root
+      const updatedCaptures = new Map<string, Path[]>();
+      for (const [name, capturePaths] of innerResult.captures) {
+        const updated: Path[] = capturePaths.map((_capturePath: Path) => {
+          // For tagged patterns, capture path is [tagged_value, content]
+          return [haystack, content];
+        });
+        updatedCaptures.set(name, updated);
+      }
+
+      return [taggedPaths, updatedCaptures];
+    }
+
+    case "Name":
+    case "Regex":
+      // For other variants, fall back to basic paths without captures
+      return [taggedPatternPaths(pattern, haystack), new Map<string, Path[]>()];
+  }
+};
+
+/**
+ * Formats a TaggedPattern as a string.
+ */
+export const taggedPatternDisplay = (
+  pattern: TaggedPattern,
+  patternDisplay: (p: Pattern) => string,
+): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "tagged";
+    case "Tag":
+      return `tagged(${pattern.tag.value}, ${patternDisplay(pattern.pattern)})`;
+    case "Name":
+      return `tagged(${pattern.name}, ${patternDisplay(pattern.pattern)})`;
+    case "Regex":
+      return `tagged(/${pattern.regex.source}/, ${patternDisplay(pattern.pattern)})`;
+  }
+};

package/src/pattern/value/bool-pattern.ts

@@ -0,0 +1,67 @@
+/**
+ * Boolean pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/bool-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { asBoolean } from "@bcts/dcbor";
+import type { Path } from "../../format";
+
+/**
+ * Pattern for matching boolean values in dCBOR.
+ */
+export type BoolPattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: boolean };
+
+/**
+ * Creates a BoolPattern that matches any boolean value.
+ */
+export const boolPatternAny = (): BoolPattern => ({ variant: "Any" });
+
+/**
+ * Creates a BoolPattern that matches a specific boolean value.
+ */
+export const boolPatternValue = (value: boolean): BoolPattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Tests if a CBOR value matches this boolean pattern.
+ */
+export const boolPatternMatches = (pattern: BoolPattern, haystack: Cbor): boolean => {
+  const value = asBoolean(haystack);
+  if (value === undefined) {
+    return false;
+  }
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Value":
+      return value === pattern.value;
+  }
+};
+
+/**
+ * Returns paths to matching boolean values.
+ */
+export const boolPatternPaths = (pattern: BoolPattern, haystack: Cbor): Path[] => {
+  if (boolPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a BoolPattern as a string.
+ */
+export const boolPatternDisplay = (pattern: BoolPattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "bool";
+    case "Value":
+      return pattern.value ? "true" : "false";
+  }
+};

package/src/pattern/value/bytes-utils.ts

@@ -0,0 +1,48 @@
+/**
+ * Byte array utility functions.
+ *
+ * @module pattern/value/bytes-utils
+ */
+
+/**
+ * Compares two Uint8Arrays for equality.
+ */
+export const bytesEqual = (a: Uint8Array, b: Uint8Array): boolean => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Tests if bytes start with a prefix.
+ */
+export const bytesStartsWith = (bytes: Uint8Array, prefix: Uint8Array): boolean => {
+  if (bytes.length < prefix.length) {
+    return false;
+  }
+  for (let i = 0; i < prefix.length; i++) {
+    if (bytes[i] !== prefix[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Converts a Uint8Array to a Latin-1 string for regex matching.
+ * Each byte value (0-255) maps directly to a character code.
+ * This mimics Rust's regex::bytes::Regex behavior.
+ */
+export const bytesToLatin1 = (bytes: Uint8Array): string => {
+  let result = "";
+  for (const byte of bytes) {
+    result += String.fromCharCode(byte);
+  }
+  return result;
+};

package/src/pattern/value/bytestring-pattern.ts

@@ -0,0 +1,111 @@
+/**
+ * ByteString pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/bytestring-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { asBytes, bytesToHex } from "@bcts/dcbor";
+import type { Path } from "../../format";
+import { bytesEqual, bytesToLatin1 } from "./bytes-utils";
+
+/**
+ * Pattern for matching byte string values in dCBOR.
+ *
+ * The BinaryRegex variant matches against raw bytes by converting them to
+ * a Latin-1 string (where each byte 0-255 maps to exactly one character).
+ * This mimics Rust's regex::bytes::Regex behavior.
+ *
+ * For example:
+ * - To match bytes starting with 0x00: `/^\x00/`
+ * - To match ASCII digits: `/^\d+$/`
+ * - To match specific hex pattern: `/\x48\x65\x6c\x6c\x6f/` (matches "Hello")
+ */
+export type ByteStringPattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: Uint8Array }
+  | { readonly variant: "BinaryRegex"; readonly pattern: RegExp };
+
+/**
+ * Creates a ByteStringPattern that matches any byte string.
+ */
+export const byteStringPatternAny = (): ByteStringPattern => ({
+  variant: "Any",
+});
+
+/**
+ * Creates a ByteStringPattern that matches a specific byte string value.
+ */
+export const byteStringPatternValue = (value: Uint8Array): ByteStringPattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Creates a ByteStringPattern that matches byte strings by binary regex.
+ *
+ * The regex matches against raw bytes converted to a Latin-1 string.
+ * Use escape sequences like `\x00` to match specific byte values.
+ *
+ * @example
+ * ```typescript
+ * // Match bytes starting with 0x00
+ * byteStringPatternBinaryRegex(/^\x00/)
+ *
+ * // Match ASCII "Hello"
+ * byteStringPatternBinaryRegex(/Hello/)
+ *
+ * // Match any digits
+ * byteStringPatternBinaryRegex(/^\d+$/)
+ * ```
+ */
+export const byteStringPatternBinaryRegex = (pattern: RegExp): ByteStringPattern => ({
+  variant: "BinaryRegex",
+  pattern,
+});
+
+/**
+ * Tests if a CBOR value matches this byte string pattern.
+ */
+export const byteStringPatternMatches = (pattern: ByteStringPattern, haystack: Cbor): boolean => {
+  const value = asBytes(haystack);
+  if (value === undefined) {
+    return false;
+  }
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Value":
+      return bytesEqual(value, pattern.value);
+    case "BinaryRegex": {
+      // Convert bytes to Latin-1 string for regex matching
+      // This mimics Rust's regex::bytes::Regex behavior
+      const latin1String = bytesToLatin1(value);
+      return pattern.pattern.test(latin1String);
+    }
+  }
+};
+
+/**
+ * Returns paths to matching byte string values.
+ */
+export const byteStringPatternPaths = (pattern: ByteStringPattern, haystack: Cbor): Path[] => {
+  if (byteStringPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a ByteStringPattern as a string.
+ */
+export const byteStringPatternDisplay = (pattern: ByteStringPattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "bstr";
+    case "Value":
+      return `h'${bytesToHex(pattern.value)}'`;
+    case "BinaryRegex":
+      return `h'/${pattern.pattern.source}/'`;
+  }
+};