@bcts/dcbor-pattern 1.0.0-alpha.11

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

@@ -0,0 +1,181 @@
+/**
+ * Number pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/number-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { asNumber, isNumber } from "@bcts/dcbor";
+import type { Path } from "../../format";
+
+/**
+ * Pattern for matching number values in dCBOR.
+ */
+export type NumberPattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: number }
+  | { readonly variant: "Range"; readonly min: number; readonly max: number }
+  | { readonly variant: "GreaterThan"; readonly value: number }
+  | { readonly variant: "GreaterThanOrEqual"; readonly value: number }
+  | { readonly variant: "LessThan"; readonly value: number }
+  | { readonly variant: "LessThanOrEqual"; readonly value: number }
+  | { readonly variant: "NaN" }
+  | { readonly variant: "Infinity" }
+  | { readonly variant: "NegInfinity" };
+
+/**
+ * Creates a NumberPattern that matches any number.
+ */
+export const numberPatternAny = (): NumberPattern => ({ variant: "Any" });
+
+/**
+ * Creates a NumberPattern that matches a specific number.
+ */
+export const numberPatternValue = (value: number): NumberPattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Creates a NumberPattern that matches numbers within a range (inclusive).
+ */
+export const numberPatternRange = (min: number, max: number): NumberPattern => ({
+  variant: "Range",
+  min,
+  max,
+});
+
+/**
+ * Creates a NumberPattern that matches numbers greater than a value.
+ */
+export const numberPatternGreaterThan = (value: number): NumberPattern => ({
+  variant: "GreaterThan",
+  value,
+});
+
+/**
+ * Creates a NumberPattern that matches numbers greater than or equal to a value.
+ */
+export const numberPatternGreaterThanOrEqual = (value: number): NumberPattern => ({
+  variant: "GreaterThanOrEqual",
+  value,
+});
+
+/**
+ * Creates a NumberPattern that matches numbers less than a value.
+ */
+export const numberPatternLessThan = (value: number): NumberPattern => ({
+  variant: "LessThan",
+  value,
+});
+
+/**
+ * Creates a NumberPattern that matches numbers less than or equal to a value.
+ */
+export const numberPatternLessThanOrEqual = (value: number): NumberPattern => ({
+  variant: "LessThanOrEqual",
+  value,
+});
+
+/**
+ * Creates a NumberPattern that matches NaN.
+ */
+export const numberPatternNaN = (): NumberPattern => ({ variant: "NaN" });
+
+/**
+ * Creates a NumberPattern that matches positive infinity.
+ */
+export const numberPatternInfinity = (): NumberPattern => ({
+  variant: "Infinity",
+});
+
+/**
+ * Creates a NumberPattern that matches negative infinity.
+ */
+export const numberPatternNegInfinity = (): NumberPattern => ({
+  variant: "NegInfinity",
+});
+
+/**
+ * Tests if a CBOR value matches this number pattern.
+ */
+export const numberPatternMatches = (pattern: NumberPattern, haystack: Cbor): boolean => {
+  switch (pattern.variant) {
+    case "Any":
+      return isNumber(haystack);
+    case "Value": {
+      const value = asNumber(haystack);
+      return value !== undefined && value === pattern.value;
+    }
+    case "Range": {
+      const value = asNumber(haystack);
+      return value !== undefined && value >= pattern.min && value <= pattern.max;
+    }
+    case "GreaterThan": {
+      const value = asNumber(haystack);
+      return value !== undefined && value > pattern.value;
+    }
+    case "GreaterThanOrEqual": {
+      const value = asNumber(haystack);
+      return value !== undefined && value >= pattern.value;
+    }
+    case "LessThan": {
+      const value = asNumber(haystack);
+      return value !== undefined && value < pattern.value;
+    }
+    case "LessThanOrEqual": {
+      const value = asNumber(haystack);
+      return value !== undefined && value <= pattern.value;
+    }
+    case "NaN": {
+      const value = asNumber(haystack);
+      return value !== undefined && Number.isNaN(value);
+    }
+    case "Infinity": {
+      const value = asNumber(haystack);
+      return value !== undefined && value === Number.POSITIVE_INFINITY;
+    }
+    case "NegInfinity": {
+      const value = asNumber(haystack);
+      return value !== undefined && value === Number.NEGATIVE_INFINITY;
+    }
+  }
+};
+
+/**
+ * Returns paths to matching number values.
+ */
+export const numberPatternPaths = (pattern: NumberPattern, haystack: Cbor): Path[] => {
+  if (numberPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a NumberPattern as a string.
+ */
+export const numberPatternDisplay = (pattern: NumberPattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "number";
+    case "Value":
+      return String(pattern.value);
+    case "Range":
+      return `${pattern.min}..${pattern.max}`;
+    case "GreaterThan":
+      return `>${pattern.value}`;
+    case "GreaterThanOrEqual":
+      return `>=${pattern.value}`;
+    case "LessThan":
+      return `<${pattern.value}`;
+    case "LessThanOrEqual":
+      return `<=${pattern.value}`;
+    case "NaN":
+      return "NaN";
+    case "Infinity":
+      return "Infinity";
+    case "NegInfinity":
+      return "-Infinity";
+  }
+};

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

@@ -0,0 +1,82 @@
+/**
+ * Text pattern for dCBOR pattern matching.
+ *
+ * @module pattern/value/text-pattern
+ */
+
+import type { Cbor } from "@bcts/dcbor";
+import { asText } from "@bcts/dcbor";
+import type { Path } from "../../format";
+
+/**
+ * Pattern for matching text values in dCBOR.
+ */
+export type TextPattern =
+  | { readonly variant: "Any" }
+  | { readonly variant: "Value"; readonly value: string }
+  | { readonly variant: "Regex"; readonly pattern: RegExp };
+
+/**
+ * Creates a TextPattern that matches any text.
+ */
+export const textPatternAny = (): TextPattern => ({ variant: "Any" });
+
+/**
+ * Creates a TextPattern that matches a specific text value.
+ */
+export const textPatternValue = (value: string): TextPattern => ({
+  variant: "Value",
+  value,
+});
+
+/**
+ * Creates a TextPattern that matches text by regex.
+ */
+export const textPatternRegex = (pattern: RegExp): TextPattern => ({
+  variant: "Regex",
+  pattern,
+});
+
+/**
+ * Tests if a CBOR value matches this text pattern.
+ */
+export const textPatternMatches = (pattern: TextPattern, haystack: Cbor): boolean => {
+  const value = asText(haystack);
+  if (value === undefined) {
+    return false;
+  }
+  switch (pattern.variant) {
+    case "Any":
+      return true;
+    case "Value":
+      return value === pattern.value;
+    case "Regex":
+      return pattern.pattern.test(value);
+  }
+};
+
+/**
+ * Returns paths to matching text values.
+ */
+export const textPatternPaths = (pattern: TextPattern, haystack: Cbor): Path[] => {
+  if (textPatternMatches(pattern, haystack)) {
+    return [[haystack]];
+  }
+  return [];
+};
+
+/**
+ * Formats a TextPattern as a string.
+ */
+export const textPatternDisplay = (pattern: TextPattern): string => {
+  switch (pattern.variant) {
+    case "Any":
+      return "text";
+    case "Value": {
+      const escaped = pattern.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      return `"${escaped}"`;
+    }
+    case "Regex":
+      return `/${pattern.pattern.source}/`;
+  }
+};