@bcts/dcbor-pattern 1.0.0-alpha.11

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

@@ -0,0 +1,162 @@
+/**
+ * Date pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/date-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { CborDate, tagValue, isTagged } from "@bcts/dcbor";
+import type { Path } from "../../format";
+
+/**
+ * Pattern for matching date values in dCBOR.
+ * Dates in CBOR are represented as tagged values with tag 1.
+ */
+export type DatePattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: CborDate }
+  | {
+      readonly variant: "Range";
+      readonly min: CborDate;
+      readonly max: CborDate;
+    }
+  | { readonly variant: "Earliest"; readonly value: CborDate }
+  | { readonly variant: "Latest"; readonly value: CborDate }
+  | { readonly variant: "StringValue"; readonly value: string }
+  | { readonly variant: "Regex"; readonly pattern: RegExp };
+
+/** CBOR tag for date (RFC 8943) */
+const DATE_TAG = 1n;
+
+/**
+ * Creates a DatePattern that matches any date.
+ */
+export const datePatternAny = (): DatePattern => ({ variant: "Any" });
+
+/**
+ * Creates a DatePattern that matches a specific date.
+ */
+export const datePatternValue = (value: CborDate): DatePattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Creates a DatePattern that matches dates within a range (inclusive).
+ */
+export const datePatternRange = (min: CborDate, max: CborDate): DatePattern => ({
+  variant: "Range",
+  min,
+  max,
+});
+
+/**
+ * Creates a DatePattern that matches dates on or after the specified date.
+ */
+export const datePatternEarliest = (value: CborDate): DatePattern => ({
+  variant: "Earliest",
+  value,
+});
+
+/**
+ * Creates a DatePattern that matches dates on or before the specified date.
+ */
+export const datePatternLatest = (value: CborDate): DatePattern => ({
+  variant: "Latest",
+  value,
+});
+
+/**
+ * Creates a DatePattern that matches dates by their ISO-8601 string representation.
+ */
+export const datePatternStringValue = (value: string): DatePattern => ({
+  variant: "StringValue",
+  value,
+});
+
+/**
+ * Creates a DatePattern that matches dates by regex on their ISO-8601 string.
+ */
+export const datePatternRegex = (pattern: RegExp): DatePattern => ({
+  variant: "Regex",
+  pattern,
+});
+
+/**
+ * Extracts a CborDate from a tagged CBOR value if it's a date (tag 1).
+ */
+const extractDate = (haystack: Cbor): CborDate | undefined => {
+  if (!isTagged(haystack)) {
+    return undefined;
+  }
+  const tag = tagValue(haystack);
+  if (tag !== DATE_TAG) {
+    return undefined;
+  }
+  try {
+    return CborDate.fromTaggedCbor(haystack);
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Tests if a CBOR value matches this date pattern.
+ */
+export const datePatternMatches = (pattern: DatePattern, haystack: Cbor): boolean => {
+  const date = extractDate(haystack);
+  if (date === undefined) {
+    return false;
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Value":
+      return date.timestamp() === pattern.value.timestamp();
+    case "Range":
+      return (
+        date.timestamp() >= pattern.min.timestamp() && date.timestamp() <= pattern.max.timestamp()
+      );
+    case "Earliest":
+      return date.timestamp() >= pattern.value.timestamp();
+    case "Latest":
+      return date.timestamp() <= pattern.value.timestamp();
+    case "StringValue":
+      return date.toString() === pattern.value;
+    case "Regex":
+      return pattern.pattern.test(date.toString());
+  }
+};
+
+/**
+ * Returns paths to matching date values.
+ */
+export const datePatternPaths = (pattern: DatePattern, haystack: Cbor): Path[] => {
+  if (datePatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a DatePattern as a string.
+ */
+export const datePatternDisplay = (pattern: DatePattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "date";
+    case "Value":
+      return `date'${pattern.value.toString()}'`;
+    case "Range":
+      return `date'${pattern.min.toString()}...${pattern.max.toString()}'`;
+    case "Earliest":
+      return `date'${pattern.value.toString()}...'`;
+    case "Latest":
+      return `date'...${pattern.value.toString()}'`;
+    case "StringValue":
+      return `date'${pattern.value}'`;
+    case "Regex":
+      return `date'/${pattern.pattern.source}/'`;
+  }
+};

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

@@ -0,0 +1,136 @@
+/**
+ * Digest pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/digest-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { tagValue, isTagged, tagContent, asBytes, bytesToHex } from "@bcts/dcbor";
+import type { Digest } from "@bcts/components";
+import type { Path } from "../../format";
+import { bytesEqual, bytesStartsWith } from "./bytes-utils";
+
+/**
+ * Pattern for matching digest values in dCBOR.
+ * Digests are represented as tagged values with tag 40001.
+ *
+ * Note: The BinaryRegex variant uses a RegExp that matches against the
+ * hex-encoded string representation of the digest bytes. This is a known
+ * difference from the Rust implementation which uses regex::bytes::Regex.
+ */
+export type DigestPattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: Digest }
+  | { readonly variant: "Prefix"; readonly prefix: Uint8Array }
+  | { readonly variant: "BinaryRegex"; readonly pattern: RegExp };
+
+/** CBOR tag for digest (BCR-2021-002) */
+const DIGEST_TAG = 40001n;
+
+/** Expected size of a SHA-256 digest */
+const DIGEST_SIZE = 32;
+
+/**
+ * Creates a DigestPattern that matches any digest.
+ */
+export const digestPatternAny = (): DigestPattern => ({ variant: "Any" });
+
+/**
+ * Creates a DigestPattern that matches a specific digest.
+ */
+export const digestPatternValue = (value: Digest): DigestPattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Creates a DigestPattern that matches digests with a prefix.
+ */
+export const digestPatternPrefix = (prefix: Uint8Array): DigestPattern => ({
+  variant: "Prefix",
+  prefix,
+});
+
+/**
+ * Creates a DigestPattern that matches digests by binary regex.
+ *
+ * Note: In TypeScript, this matches against the hex-encoded representation
+ * of the digest bytes.
+ */
+export const digestPatternBinaryRegex = (pattern: RegExp): DigestPattern => ({
+  variant: "BinaryRegex",
+  pattern,
+});
+
+/**
+ * Extracts digest bytes from a tagged CBOR value if it's a digest (tag 40001).
+ */
+const extractDigestBytes = (haystack: Cbor): Uint8Array | undefined => {
+  if (!isTagged(haystack)) {
+    return undefined;
+  }
+  const tag = tagValue(haystack);
+  if (tag !== DIGEST_TAG) {
+    return undefined;
+  }
+  const content = tagContent(haystack);
+  if (content === undefined) {
+    return undefined;
+  }
+  const bytes = asBytes(content);
+  if (bytes?.length !== DIGEST_SIZE) {
+    return undefined;
+  }
+  return bytes;
+};
+
+/**
+ * Tests if a CBOR value matches this digest pattern.
+ */
+export const digestPatternMatches = (pattern: DigestPattern, haystack: Cbor): boolean => {
+  const digestBytes = extractDigestBytes(haystack);
+  if (digestBytes === undefined) {
+    return false;
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Value":
+      return bytesEqual(digestBytes, pattern.value.data());
+    case "Prefix":
+      return bytesStartsWith(digestBytes, pattern.prefix);
+    case "BinaryRegex": {
+      // Convert bytes to hex string for regex matching
+      const hexString = bytesToHex(digestBytes);
+      return pattern.pattern.test(hexString);
+    }
+  }
+};
+
+/**
+ * Returns paths to matching digest values.
+ */
+export const digestPatternPaths = (pattern: DigestPattern, haystack: Cbor): Path[] => {
+  if (digestPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a DigestPattern as a string.
+ */
+export const digestPatternDisplay = (pattern: DigestPattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "digest";
+    case "Value":
+      // Use UR string if available, otherwise hex
+      return `digest'${bytesToHex(pattern.value.data())}'`;
+    case "Prefix":
+      return `digest'${bytesToHex(pattern.prefix)}'`;
+    case "BinaryRegex":
+      return `digest'/${pattern.pattern.source}/'`;
+  }
+};

package/src/pattern/value/index.ts

@@ -0,0 +1,168 @@
+/**
+ * Value patterns for dCBOR pattern matching.
+ *
+ * @module pattern/value
+ */
+
+export * from "./bool-pattern";
+export * from "./null-pattern";
+export * from "./number-pattern";
+export * from "./text-pattern";
+export * from "./bytestring-pattern";
+export * from "./date-pattern";
+export * from "./digest-pattern";
+export * from "./known-value-pattern";
+
+import type { Cbor } from "@bcts/dcbor";
+import type { Path } from "../../format";
+
+import { type BoolPattern, boolPatternPaths, boolPatternDisplay } from "./bool-pattern";
+import { type NullPattern, nullPatternPaths, nullPatternDisplay } from "./null-pattern";
+import { type NumberPattern, numberPatternPaths, numberPatternDisplay } from "./number-pattern";
+import { type TextPattern, textPatternPaths, textPatternDisplay } from "./text-pattern";
+import {
+  type ByteStringPattern,
+  byteStringPatternPaths,
+  byteStringPatternDisplay,
+} from "./bytestring-pattern";
+import { type DatePattern, datePatternPaths, datePatternDisplay } from "./date-pattern";
+import { type DigestPattern, digestPatternPaths, digestPatternDisplay } from "./digest-pattern";
+import {
+  type KnownValuePattern,
+  knownValuePatternPaths,
+  knownValuePatternDisplay,
+} from "./known-value-pattern";
+
+/**
+ * Union of all value pattern types.
+ */
+export type ValuePattern =
+  | { readonly type: "Bool"; readonly pattern: BoolPattern }
+  | { readonly type: "Null"; readonly pattern: NullPattern }
+  | { readonly type: "Number"; readonly pattern: NumberPattern }
+  | { readonly type: "Text"; readonly pattern: TextPattern }
+  | { readonly type: "ByteString"; readonly pattern: ByteStringPattern }
+  | { readonly type: "Date"; readonly pattern: DatePattern }
+  | { readonly type: "Digest"; readonly pattern: DigestPattern }
+  | { readonly type: "KnownValue"; readonly pattern: KnownValuePattern };
+
+/**
+ * Returns paths to matching values for a ValuePattern.
+ */
+export const valuePatternPaths = (pattern: ValuePattern, haystack: Cbor): Path[] => {
+  switch (pattern.type) {
+    case "Bool":
+      return boolPatternPaths(pattern.pattern, haystack);
+    case "Null":
+      return nullPatternPaths(pattern.pattern, haystack);
+    case "Number":
+      return numberPatternPaths(pattern.pattern, haystack);
+    case "Text":
+      return textPatternPaths(pattern.pattern, haystack);
+    case "ByteString":
+      return byteStringPatternPaths(pattern.pattern, haystack);
+    case "Date":
+      return datePatternPaths(pattern.pattern, haystack);
+    case "Digest":
+      return digestPatternPaths(pattern.pattern, haystack);
+    case "KnownValue":
+      return knownValuePatternPaths(pattern.pattern, haystack);
+  }
+};
+
+/**
+ * Tests if a CBOR value matches a ValuePattern.
+ */
+export const valuePatternMatches = (pattern: ValuePattern, haystack: Cbor): boolean => {
+  return valuePatternPaths(pattern, haystack).length > 0;
+};
+
+/**
+ * Formats a ValuePattern as a string.
+ */
+export const valuePatternDisplay = (pattern: ValuePattern): string => {
+  switch (pattern.type) {
+    case "Bool":
+      return boolPatternDisplay(pattern.pattern);
+    case "Null":
+      return nullPatternDisplay(pattern.pattern);
+    case "Number":
+      return numberPatternDisplay(pattern.pattern);
+    case "Text":
+      return textPatternDisplay(pattern.pattern);
+    case "ByteString":
+      return byteStringPatternDisplay(pattern.pattern);
+    case "Date":
+      return datePatternDisplay(pattern.pattern);
+    case "Digest":
+      return digestPatternDisplay(pattern.pattern);
+    case "KnownValue":
+      return knownValuePatternDisplay(pattern.pattern);
+  }
+};
+
+// Convenience constructors for ValuePattern
+
+/**
+ * Creates a Bool ValuePattern.
+ */
+export const valueBool = (pattern: BoolPattern): ValuePattern => ({
+  type: "Bool",
+  pattern,
+});
+
+/**
+ * Creates a Null ValuePattern.
+ */
+export const valueNull = (pattern: NullPattern): ValuePattern => ({
+  type: "Null",
+  pattern,
+});
+
+/**
+ * Creates a Number ValuePattern.
+ */
+export const valueNumber = (pattern: NumberPattern): ValuePattern => ({
+  type: "Number",
+  pattern,
+});
+
+/**
+ * Creates a Text ValuePattern.
+ */
+export const valueText = (pattern: TextPattern): ValuePattern => ({
+  type: "Text",
+  pattern,
+});
+
+/**
+ * Creates a ByteString ValuePattern.
+ */
+export const valueByteString = (pattern: ByteStringPattern): ValuePattern => ({
+  type: "ByteString",
+  pattern,
+});
+
+/**
+ * Creates a Date ValuePattern.
+ */
+export const valueDate = (pattern: DatePattern): ValuePattern => ({
+  type: "Date",
+  pattern,
+});
+
+/**
+ * Creates a Digest ValuePattern.
+ */
+export const valueDigest = (pattern: DigestPattern): ValuePattern => ({
+  type: "Digest",
+  pattern,
+});
+
+/**
+ * Creates a KnownValue ValuePattern.
+ */
+export const valueKnownValue = (pattern: KnownValuePattern): ValuePattern => ({
+  type: "KnownValue",
+  pattern,
+});

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

@@ -0,0 +1,123 @@
+/**
+ * KnownValue pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/known-value-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { tagValue, isTagged, tagContent, asUnsigned } from "@bcts/dcbor";
+import { KnownValue, KNOWN_VALUE_TAG } from "@bcts/known-values";
+import type { Path } from "../../format";
+
+/**
+ * Pattern for matching known values in dCBOR.
+ * Known values are represented as tagged values with tag 40000.
+ */
+export type KnownValuePattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: KnownValue }
+  | { readonly variant: "Named"; readonly name: string }
+  | { readonly variant: "Regex"; readonly pattern: RegExp };
+
+/**
+ * Creates a KnownValuePattern that matches any known value.
+ */
+export const knownValuePatternAny = (): KnownValuePattern => ({
+  variant: "Any",
+});
+
+/**
+ * Creates a KnownValuePattern that matches a specific known value.
+ */
+export const knownValuePatternValue = (value: KnownValue): KnownValuePattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Creates a KnownValuePattern that matches a known value by name.
+ */
+export const knownValuePatternNamed = (name: string): KnownValuePattern => ({
+  variant: "Named",
+  name,
+});
+
+/**
+ * Creates a KnownValuePattern that matches known values by regex on name.
+ */
+export const knownValuePatternRegex = (pattern: RegExp): KnownValuePattern => ({
+  variant: "Regex",
+  pattern,
+});
+
+/**
+ * Extracts a KnownValue from a tagged CBOR value if it's a known value (tag 40000).
+ */
+const extractKnownValue = (haystack: Cbor): KnownValue | undefined => {
+  if (!isTagged(haystack)) {
+    return undefined;
+  }
+  const tag = tagValue(haystack);
+  if (tag !== KNOWN_VALUE_TAG.value) {
+    return undefined;
+  }
+  const content = tagContent(haystack);
+  if (content === undefined) {
+    return undefined;
+  }
+  const value = asUnsigned(content);
+  if (value === undefined) {
+    return undefined;
+  }
+  return new KnownValue(value);
+};
+
+/**
+ * Tests if a CBOR value matches this known value pattern.
+ */
+export const knownValuePatternMatches = (pattern: KnownValuePattern, haystack: Cbor): boolean => {
+  const knownValue = extractKnownValue(haystack);
+  if (knownValue === undefined) {
+    return false;
+  }
+
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Value":
+      return knownValue.valueBigInt() === pattern.value.valueBigInt();
+    case "Named": {
+      // Look up the known value by name and compare
+      // KnownValue has a name method that we can compare
+      return knownValue.name() === pattern.name;
+    }
+    case "Regex":
+      return pattern.pattern.test(knownValue.name());
+  }
+};
+
+/**
+ * Returns paths to matching known values.
+ */
+export const knownValuePatternPaths = (pattern: KnownValuePattern, haystack: Cbor): Path[] => {
+  if (knownValuePatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a KnownValuePattern as a string.
+ */
+export const knownValuePatternDisplay = (pattern: KnownValuePattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "known";
+    case "Value":
+      return `'${pattern.value.name()}'`;
+    case "Named":
+      return `'${pattern.name}'`;
+    case "Regex":
+      return `'/${pattern.pattern.source}/'`;
+  }
+};

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

@@ -0,0 +1,46 @@
+/**
+ * Null pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/null-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { isNull } from "@bcts/dcbor";
+import type { Path } from "../../format";
+
+/**
+ * Pattern for matching null values in dCBOR.
+ * This is a unit type - there's only one way to match null.
+ */
+export interface NullPattern {
+  readonly variant: "Null";
+}
+
+/**
+ * Creates a NullPattern.
+ */
+export const nullPattern = (): NullPattern => ({ variant: "Null" });
+
+/**
+ * Tests if a CBOR value matches the null pattern.
+ */
+export const nullPatternMatches = (_pattern: NullPattern, haystack: Cbor): boolean => {
+  return isNull(haystack);
+};
+
+/**
+ * Returns paths to matching null values.
+ */
+export const nullPatternPaths = (pattern: NullPattern, haystack: Cbor): Path[] => {
+  if (nullPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a NullPattern as a string.
+ */
+export const nullPatternDisplay = (_pattern: NullPattern): string => {
+  return "null";
+};