@bcts/dcbor-pattern 1.0.0-alpha.11

package/src/parse/value/bool-parser.ts

@@ -0,0 +1,33 @@
+/**
+ * Bool pattern parser.
+ *
+ * @module parse/value/bool-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { anyBool, bool } from "../../pattern";
+
+/**
+ * Parse a boolean pattern from the `bool` keyword.
+ */
+export const parseBool = (_lexer: Lexer): Result<Pattern> => {
+  // `bool` keyword was already consumed, just return the pattern
+  return Ok(anyBool());
+};
+
+/**
+ * Parse a `true` literal.
+ */
+export const parseBoolTrue = (_lexer: Lexer): Result<Pattern> => {
+  return Ok(bool(true));
+};
+
+/**
+ * Parse a `false` literal.
+ */
+export const parseBoolFalse = (_lexer: Lexer): Result<Pattern> => {
+  return Ok(bool(false));
+};

package/src/parse/value/bytestring-parser.ts

@@ -0,0 +1,42 @@
+/**
+ * ByteString pattern parser.
+ *
+ * @module parse/value/bytestring-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { anyByteString, byteString, byteStringRegex } from "../../pattern";
+
+/**
+ * Parse a bytestring pattern from the `bytes` keyword.
+ */
+export const parseByteString = (_lexer: Lexer): Result<Pattern> => {
+  // `bytes` keyword was already consumed
+  return Ok(anyByteString());
+};
+
+/**
+ * Parse a hex string token result into a pattern.
+ */
+export const parseHexStringToken = (hexResult: Result<Uint8Array>): Result<Pattern> => {
+  if (!hexResult.ok) {
+    return hexResult;
+  }
+  return Ok(byteString(hexResult.value));
+};
+
+/**
+ * Parse a hex regex token result into a pattern.
+ *
+ * In TypeScript, binary regex matching is implemented by converting bytes to Latin-1 strings.
+ * This mimics Rust's regex::bytes::Regex behavior where each byte 0-255 maps to a character.
+ */
+export const parseHexRegexToken = (regexResult: Result<RegExp>): Result<Pattern> => {
+  if (!regexResult.ok) {
+    return regexResult;
+  }
+  return Ok(byteStringRegex(regexResult.value));
+};

package/src/parse/value/date-parser.ts

@@ -0,0 +1,24 @@
+/**
+ * Date pattern parser.
+ *
+ * @module parse/value/date-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+
+// Import date pattern constructor
+import { datePatternAny } from "../../pattern/value/date-pattern";
+
+/**
+ * Parse a date pattern from the `date` keyword.
+ */
+export const parseDate = (_lexer: Lexer): Result<Pattern> => {
+  // `date` keyword was already consumed
+  return Ok({
+    kind: "Value",
+    pattern: { type: "Date", pattern: datePatternAny() },
+  });
+};

package/src/parse/value/digest-parser.ts

@@ -0,0 +1,24 @@
+/**
+ * Digest pattern parser.
+ *
+ * @module parse/value/digest-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+
+// Import digest pattern constructor
+import { digestPatternAny } from "../../pattern/value/digest-pattern";
+
+/**
+ * Parse a digest pattern from the `digest` keyword.
+ */
+export const parseDigest = (_lexer: Lexer): Result<Pattern> => {
+  // `digest` keyword was already consumed
+  return Ok({
+    kind: "Value",
+    pattern: { type: "Digest", pattern: digestPatternAny() },
+  });
+};

package/src/parse/value/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Value parsers for dCBOR patterns.
+ *
+ * @module parse/value
+ */
+
+export * from "./bool-parser";
+export * from "./null-parser";
+export * from "./number-parser";
+export * from "./text-parser";
+export * from "./bytestring-parser";
+export * from "./date-parser";
+export * from "./digest-parser";
+export * from "./known-value-parser";

package/src/parse/value/known-value-parser.ts

@@ -0,0 +1,24 @@
+/**
+ * KnownValue pattern parser.
+ *
+ * @module parse/value/known-value-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+
+// Import known value pattern constructor
+import { knownValuePatternAny } from "../../pattern/value/known-value-pattern";
+
+/**
+ * Parse a known value pattern from the `known` keyword.
+ */
+export const parseKnownValue = (_lexer: Lexer): Result<Pattern> => {
+  // `known` keyword was already consumed
+  return Ok({
+    kind: "Value",
+    pattern: { type: "KnownValue", pattern: knownValuePatternAny() },
+  });
+};

package/src/parse/value/null-parser.ts

@@ -0,0 +1,19 @@
+/**
+ * Null pattern parser.
+ *
+ * @module parse/value/null-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { nullPattern } from "../../pattern";
+
+/**
+ * Parse a null pattern from the `null` keyword.
+ */
+export const parseNull = (_lexer: Lexer): Result<Pattern> => {
+  // `null` keyword was already consumed
+  return Ok(nullPattern());
+};

package/src/parse/value/number-parser.ts

@@ -0,0 +1,19 @@
+/**
+ * Number pattern parser.
+ *
+ * @module parse/value/number-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok } from "../../error";
+import { anyNumber } from "../../pattern";
+
+/**
+ * Parse a number pattern from the `number` keyword.
+ */
+export const parseNumber = (_lexer: Lexer): Result<Pattern> => {
+  // `number` keyword was already consumed
+  return Ok(anyNumber());
+};

package/src/parse/value/text-parser.ts

@@ -0,0 +1,43 @@
+/**
+ * Text pattern parser.
+ *
+ * @module parse/value/text-parser
+ */
+
+import type { Lexer } from "../token";
+import type { Pattern } from "../../pattern";
+import type { Result } from "../../error";
+import { Ok, Err } from "../../error";
+import { anyText, text, textRegex } from "../../pattern";
+
+/**
+ * Parse a text pattern from the `text` keyword.
+ */
+export const parseText = (lexer: Lexer): Result<Pattern> => {
+  // `text` keyword was already consumed
+  // Check if followed by a quoted value
+  const peeked = lexer.peekToken();
+  if (peeked?.ok === true) {
+    const token = peeked.value;
+    if (token.type === "SingleQuoted") {
+      lexer.next(); // consume the token
+      // Check if it's a regex (starts and ends with /)
+      if (token.value.startsWith("/") && token.value.endsWith("/") && token.value.length > 2) {
+        const regexBody = token.value.slice(1, -1);
+        try {
+          const regex = new RegExp(regexBody);
+          return Ok(textRegex(regex));
+        } catch {
+          return Err({ type: "InvalidRegex", span: lexer.span() });
+        }
+      }
+      // Otherwise it's a literal string match
+      return Ok(text(token.value));
+    }
+    if (token.type === "StringLiteral") {
+      lexer.next(); // consume the token
+      return Ok(text(token.value));
+    }
+  }
+  return Ok(anyText());
+};