@rethinkhealth/hl7v2-utils 0.4.2 → 0.5.0

package/README.md

@@ -32,27 +32,27 @@ Report a diagnostic to a VFile. This function is the standard way to report issu
 #### Example
 
 ```typescript
-import { report } from '@rethinkhealth/hl7v2-utils';
-import type { Diagnostic } from '@rethinkhealth/hl7v2-utils';
-import { VFile } from 'vfile';
+import { report } from "@rethinkhealth/hl7v2-utils";
+import type { Diagnostic } from "@rethinkhealth/hl7v2-utils";
+import { VFile } from "vfile";
 
 // Define a diagnostic rule
 const requiredFieldRule: Diagnostic = {
-  type: 'lint',
-  namespace: 'field',
-  code: 'required',
-  title: 'Required Field Missing',
-  description: 'A required field is missing from the segment.',
-  severity: 'error',
+  type: "lint",
+  namespace: "field",
+  code: "required",
+  title: "Required Field Missing",
+  description: "A required field is missing from the segment.",
+  severity: "error",
   message: (ctx) => `Field '${ctx.fieldPath}' is required`,
-  helpUrl: 'https://example.com/docs/required-field'
+  helpUrl: "https://example.com/docs/required-field",
 };
 
 // Report the diagnostic
 const file = new VFile();
 report(file, requiredFieldRule, {
-  context: { fieldPath: 'PID-5' },
-  node: segmentNode
+  context: { fieldPath: "PID-5" },
+  node: segmentNode,
 });
 ```
 
@@ -81,25 +81,25 @@ The function is optimized for performance with O(n) time complexity where n is t
 #### Example
 
 ```typescript
-import { getByteLength } from '@rethinkhealth/hl7v2-utils';
-import type { Field } from '@rethinkhealth/hl7v2-ast';
+import { getByteLength } from "@rethinkhealth/hl7v2-utils";
+import type { Field } from "@rethinkhealth/hl7v2-ast";
 
 const field: Field = {
-  type: 'field',
+  type: "field",
   children: [
     {
-      type: 'field-repetition',
+      type: "field-repetition",
       children: [
         {
-          type: 'component',
+          type: "component",
           children: [
-            { type: 'subcomponent', value: 'SMITH' },
-            { type: 'subcomponent', value: 'JOHN' }
-          ]
-        }
-      ]
-    }
-  ]
+            { type: "subcomponent", value: "SMITH" },
+            { type: "subcomponent", value: "JOHN" },
+          ],
+        },
+      ],
+    },
+  ],
 };
 
 // Calculate: SMITH&JOHN = 5 + 1 + 4 = 10 bytes
@@ -142,25 +142,25 @@ The function is optimized for performance with O(n) time complexity where n is t
 #### Example
 
 ```typescript
-import { getLength } from '@rethinkhealth/hl7v2-utils';
-import type { Field } from '@rethinkhealth/hl7v2-ast';
+import { getLength } from "@rethinkhealth/hl7v2-utils";
+import type { Field } from "@rethinkhealth/hl7v2-ast";
 
 const field: Field = {
-  type: 'field',
+  type: "field",
   children: [
     {
-      type: 'field-repetition',
+      type: "field-repetition",
       children: [
         {
-          type: 'component',
+          type: "component",
           children: [
-            { type: 'subcomponent', value: 'SMITH' },
-            { type: 'subcomponent', value: 'JOHN' }
-          ]
-        }
-      ]
-    }
-  ]
+            { type: "subcomponent", value: "SMITH" },
+            { type: "subcomponent", value: "JOHN" },
+          ],
+        },
+      ],
+    },
+  ],
 };
 
 // Calculate: SMITH&JOHN = 5 + 1 + 4 = 10 characters
@@ -177,11 +177,11 @@ const length = getLength(field); // Returns: 10
 #### Comparison with `getByteLength`
 
 ```typescript
-import { getLength, getByteLength } from '@rethinkhealth/hl7v2-utils';
+import { getLength, getByteLength } from "@rethinkhealth/hl7v2-utils";
 
-const subcomponent = { type: 'subcomponent', value: 'café' };
+const subcomponent = { type: "subcomponent", value: "café" };
 
-getLength(subcomponent);     // Returns: 4 (4 characters)
+getLength(subcomponent); // Returns: 4 (4 characters)
 getByteLength(subcomponent); // Returns: 5 (5 bytes in UTF-8: c-a-f-C3-A9)
 ```
 
@@ -194,16 +194,16 @@ The package provides stateless, composable functions to validate HL7v2 AST nodes
 All conformance functions return a `ValidationResult` object:
 
 ```typescript
-type ValidationResult = 
+type ValidationResult =
   | { ok: true }
-  | { 
-      ok: false; 
-      error: { 
-        code: string; 
+  | {
+      ok: false;
+      error: {
+        code: string;
         message: string;
         expected?: string | number | Array<string | number>;
         actual?: string | number | Array<string | number>;
-      } 
+      };
     };
 ```
 
@@ -216,10 +216,10 @@ Checks if a node satisfies the optionality (usage) constraint.
 - **Returns**: `ValidationResult`
 
 ```typescript
-import { checkOptionality } from '@rethinkhealth/hl7v2-utils';
+import { checkOptionality } from "@rethinkhealth/hl7v2-utils";
 
 // 'R' (Required), 'RE' (Required or Empty), 'O' (Optional), 'X' (Not Supported)
-const result = checkOptionality(myFieldNode, 'R');
+const result = checkOptionality(myFieldNode, "R");
 
 if (!result.ok) {
   console.error(result.error.message); // "is required but missing"
@@ -236,7 +236,7 @@ Checks if a field has the correct number of repetitions.
 - **Returns**: `ValidationResult`
 
 ```typescript
-import { checkCardinality } from '@rethinkhealth/hl7v2-utils';
+import { checkCardinality } from "@rethinkhealth/hl7v2-utils";
 
 // Field must repeat between 1 and 5 times
 const result = checkCardinality(myFieldNode, 1, 5);
@@ -252,7 +252,7 @@ Checks if the content of a node falls within the minimum and maximum length.
 - **Returns**: `ValidationResult`
 
 ```typescript
-import { checkLength } from '@rethinkhealth/hl7v2-utils';
+import { checkLength } from "@rethinkhealth/hl7v2-utils";
 
 // Content length must be between 1 and 10 characters
 const result = checkLength(myNode, 10, 1);

package/dist/constants.d.ts

@@ -1,9 +1,9 @@
 export declare const DEFAULT_DELIMITERS: {
-    field: string;
     component: string;
-    repetition: string;
-    subcomponent: string;
     escape: string;
+    field: string;
+    repetition: string;
     segment: string;
+    subcomponent: string;
 };
 //# sourceMappingURL=constants.d.ts.map

package/dist/constraints.d.ts

@@ -1,50 +1,28 @@
 import type { Field, Nodes } from "@rethinkhealth/hl7v2-ast";
 export type ValidationErrorCode = "MISSING" | "EMPTY" | "UNEXPECTED_CONTENT" | "CARDINALITY_UNDERFLOW" | "CARDINALITY_OVERFLOW" | "LENGTH_UNDERFLOW" | "LENGTH_OVERFLOW" | "VALUE_NOT_IN_TABLE";
-export type ValidationError = {
+export interface ValidationError {
     code: ValidationErrorCode;
     message: string;
     expected?: string | number | Array<string | number>;
     actual?: string | number | Array<string | number>;
-};
-export type ValidationSuccess = {
+}
+export interface ValidationSuccess {
     ok: true;
-};
-export type ValidationFailure = {
+}
+export interface ValidationFailure {
     ok: false;
     error: ValidationError;
-};
+}
 export type ValidationResult = ValidationSuccess | ValidationFailure;
 export declare const OptionalityCode: {
-    readonly Required: "R";
-    /**
-     * Required, but may be empty.
-     *
-     * @remarks
-     * The use of the RE usage code is qualified with the “if data is known”
-     * clause. The sender must interpret the clause as “the capability must always
-     * be supported, and data must always be sent if known”. To clarify, the
-     * sender does not determine whether the data should be sent; to be conformant
-     * to the rule, the data must be sent. There is a misconception where the RE
-     * usage is interpreted as “the capability must always be supported, and data
-     * may or may not be sent even when known based on a condition external to the
-     * profile specification”.
-     *
-     * The receiving application must process in a meaningful way the information
-     * conveyed by an element with an “RE” usage designation.
-     * The receiving application must process the message if the element is omitted
-     * (that is, an exception must not be raised because the element is missing). A
-     * receiving application must not raise an exception due to the presence of a
-     * required element.
-     */
-    readonly RequiredOrEmpty: "RE";
     /**
-     * Optional
+     * Backward Compatible
      *
-     * There are no implementation requirements. The “O” usage designation is a
-     * placeholder indicating that the usage for this element has not yet been
-     * specified.
+     * There are no implementation requirements. The “B” usage indicates that the
+     * element is retained for backwards compatibility of the element. Another
+     * usage indicator may be assigned in a derived profile.
      */
-    readonly Optional: "O";
+    readonly BackwardCompatible: "B";
     /**
      * Undeclared / Conditional.
      *
@@ -61,13 +39,37 @@ export declare const OptionalityCode: {
      */
     readonly NotSupported: "X";
     /**
-     * Backward Compatible
+     * Optional
      *
-     * There are no implementation requirements. The “B” usage indicates that the
-     * element is retained for backwards compatibility of the element. Another
-     * usage indicator may be assigned in a derived profile.
+     * There are no implementation requirements. The “O” usage designation is a
+     * placeholder indicating that the usage for this element has not yet been
+     * specified.
      */
-    readonly BackwardCompatible: "B";
+    readonly Optional: "O";
+    /**
+     * Required
+     */
+    readonly Required: "R";
+    /**
+     * Required, but may be empty.
+     *
+     * The use of the RE usage code is qualified with the “if data is known”
+     * clause. The sender must interpret the clause as “the capability must always
+     * be supported, and data must always be sent if known”. To clarify, the
+     * sender does not determine whether the data should be sent; to be conformant
+     * to the rule, the data must be sent. There is a misconception where the RE
+     * usage is interpreted as “the capability must always be supported, and data
+     * may or may not be sent even when known based on a condition external to the
+     * profile specification”.
+     *
+     * The receiving application must process in a meaningful way the information
+     * conveyed by an element with an “RE” usage designation.
+     * The receiving application must process the message if the element is omitted
+     * (that is, an exception must not be raised because the element is missing). A
+     * receiving application must not raise an exception due to the presence of a
+     * required element.
+     */
+    readonly RequiredOrEmpty: "RE";
     /**
      * Withdrawn
      *

package/dist/constraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../src/constraints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG7D,MAAM,MAAM,mBAAmB,GAE3B,SAAS,GACT,OAAO,GACP,oBAAoB,GACpB,uBAAuB,GACvB,sBAAsB,GACtB,kBAAkB,GAClB,iBAAiB,GAEjB,oBAAoB,CAAC;AAEzB,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACpD,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,IAAI,CAAC;CACV,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAErE,eAAO,MAAM,eAAe;;IAE1B;;;;;;;;;;;;;;;;;;;OAmBG;;IAEH;;;;;;OAMG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;;;;;OAMG;;IAEH;;;;;;OAMG;;CAEK,CAAC;AAEX,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAEzD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GAAG,GAAG,GAChB,gBAAgB,CAoClB;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,SAAI,GACN,gBAAgB,CAoClB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,WAAW,EAAE,eAAe,GAAG,MAAM,GACpC,gBAAgB,CAkDlB"}
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../src/constraints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAI7D,MAAM,MAAM,mBAAmB,GAE3B,SAAS,GACT,OAAO,GACP,oBAAoB,GACpB,uBAAuB,GACvB,sBAAsB,GACtB,kBAAkB,GAClB,iBAAiB,GAEjB,oBAAoB,CAAC;AAEzB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACpD,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,IAAI,CAAC;CACV;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,eAAe,CAAC;CACxB;AAED,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAErE,eAAO,MAAM,eAAe;IAC1B;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;OAEG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;OAMG;;CAEK,CAAC;AAEX,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAEzD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GAAG,GAAG,GAChB,gBAAgB,CAoClB;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,SAAI,GACN,gBAAgB,CAoClB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,WAAW,EAAE,eAAe,GAAG,MAAM,GACpC,gBAAgB,CAsDlB"}

package/dist/index.js

@@ -1,11 +1,11 @@
 // src/constants.ts
 var DEFAULT_DELIMITERS = {
-  field: "|",
   component: "^",
-  repetition: "~",
-  subcomponent: "&",
   escape: "\\",
-  segment: "\r"
+  field: "|",
+  repetition: "~",
+  segment: "\r",
+  subcomponent: "&"
 };
 
 // src/utils.ts
@@ -34,10 +34,8 @@ function getByteLength(node) {
   if ("value" in node) {
     return Buffer.byteLength(node.value, "utf8");
   }
-  return node.children.reduce(
-    (total, child) => total + getByteLength(child),
-    0
-  );
+  const nameLength = node.type === "segment" ? Buffer.byteLength(node.name, "utf8") : 0;
+  return nameLength + node.children.reduce((total, child) => total + getByteLength(child), 0);
 }
 function getLength(node) {
   if (!node) {
@@ -46,41 +44,20 @@ function getLength(node) {
   if ("value" in node) {
     return node.value.length;
   }
-  return node.children.reduce((total, child) => total + getLength(child), 0);
+  const nameLength = node.type === "segment" ? node.name.length : 0;
+  return nameLength + node.children.reduce((total, child) => total + getLength(child), 0);
 }
 
 // src/constraints.ts
 var OptionalityCode = {
-  Required: "R",
-  /**
-   * Required, but may be empty.
-   *
-   * @remarks
-   * The use of the RE usage code is qualified with the “if data is known”
-   * clause. The sender must interpret the clause as “the capability must always
-   * be supported, and data must always be sent if known”. To clarify, the
-   * sender does not determine whether the data should be sent; to be conformant
-   * to the rule, the data must be sent. There is a misconception where the RE
-   * usage is interpreted as “the capability must always be supported, and data
-   * may or may not be sent even when known based on a condition external to the
-   * profile specification”.
-   *
-   * The receiving application must process in a meaningful way the information
-   * conveyed by an element with an “RE” usage designation.
-   * The receiving application must process the message if the element is omitted
-   * (that is, an exception must not be raised because the element is missing). A
-   * receiving application must not raise an exception due to the presence of a
-   * required element.
-   */
-  RequiredOrEmpty: "RE",
   /**
-   * Optional
+   * Backward Compatible
    *
-   * There are no implementation requirements. The “O” usage designation is a
-   * placeholder indicating that the usage for this element has not yet been
-   * specified.
+   * There are no implementation requirements. The “B” usage indicates that the
+   * element is retained for backwards compatibility of the element. Another
+   * usage indicator may be assigned in a derived profile.
    */
-  Optional: "O",
+  BackwardCompatible: "B",
   /**
    * Undeclared / Conditional.
    *
@@ -97,13 +74,37 @@ var OptionalityCode = {
    */
   NotSupported: "X",
   /**
-   * Backward Compatible
+   * Optional
    *
-   * There are no implementation requirements. The “B” usage indicates that the
-   * element is retained for backwards compatibility of the element. Another
-   * usage indicator may be assigned in a derived profile.
+   * There are no implementation requirements. The “O” usage designation is a
+   * placeholder indicating that the usage for this element has not yet been
+   * specified.
    */
-  BackwardCompatible: "B",
+  Optional: "O",
+  /**
+   * Required
+   */
+  Required: "R",
+  /**
+   * Required, but may be empty.
+   *
+   * The use of the RE usage code is qualified with the “if data is known”
+   * clause. The sender must interpret the clause as “the capability must always
+   * be supported, and data must always be sent if known”. To clarify, the
+   * sender does not determine whether the data should be sent; to be conformant
+   * to the rule, the data must be sent. There is a misconception where the RE
+   * usage is interpreted as “the capability must always be supported, and data
+   * may or may not be sent even when known based on a condition external to the
+   * profile specification”.
+   *
+   * The receiving application must process in a meaningful way the information
+   * conveyed by an element with an “RE” usage designation.
+   * The receiving application must process the message if the element is omitted
+   * (that is, an exception must not be raised because the element is missing). A
+   * receiving application must not raise an exception due to the presence of a
+   * required element.
+   */
+  RequiredOrEmpty: "RE",
   /**
    * Withdrawn
    *
@@ -123,24 +124,24 @@ function checkCardinality(node, min, max) {
   const count = node?.children ? node.children.length : 0;
   if (count < min) {
     return {
-      ok: false,
       error: {
+        actual: count,
         code: "CARDINALITY_UNDERFLOW",
-        message: `has ${count} repetitions but requires at least ${min}`,
         expected: min,
-        actual: count
-      }
+        message: `has ${count} repetitions but requires at least ${min}`
+      },
+      ok: false
     };
   }
   if (max !== "*" && count > max) {
     return {
-      ok: false,
       error: {
+        actual: count,
         code: "CARDINALITY_OVERFLOW",
-        message: `has ${count} repetitions but allows at most ${max}`,
         expected: max,
-        actual: count
-      }
+        message: `has ${count} repetitions but allows at most ${max}`
+      },
+      ok: false
     };
   }
   return { ok: true };
@@ -155,24 +156,24 @@ function checkLength(node, max, min = 0) {
   const length = getLength(node);
   if (length < min) {
     return {
-      ok: false,
       error: {
+        actual: length,
         code: "LENGTH_UNDERFLOW",
-        message: `has length ${length} but requires at least ${min}`,
         expected: min,
-        actual: length
-      }
+        message: `has length ${length} but requires at least ${min}`
+      },
+      ok: false
     };
   }
   if (length > max) {
     return {
-      ok: false,
       error: {
+        actual: length,
         code: "LENGTH_OVERFLOW",
-        message: `has length ${length} but allows at most ${max}`,
         expected: max,
-        actual: length
-      }
+        message: `has length ${length} but allows at most ${max}`
+      },
+      ok: false
     };
   }
   return { ok: true };
@@ -180,48 +181,52 @@ function checkLength(node, max, min = 0) {
 function checkOptionality(node, optionality) {
   const code = optionality.toUpperCase();
   switch (code) {
-    case OptionalityCode.Required:
+    case OptionalityCode.Required: {
       if (!node) {
         return {
-          ok: false,
           error: {
             code: "MISSING",
-            message: "is required but missing",
-            expected: "R"
-          }
+            expected: "R",
+            message: "is required but missing"
+          },
+          ok: false
         };
       }
       if (isEmptyNode(node)) {
         return {
-          ok: false,
           error: {
             code: "EMPTY",
-            message: "is required but empty",
-            expected: "R"
-          }
+            expected: "R",
+            message: "is required but empty"
+          },
+          ok: false
         };
       }
       return { ok: true };
-    case OptionalityCode.NotSupported:
+    }
+    case OptionalityCode.NotSupported: {
       if (node && !isEmptyNode(node)) {
         return {
-          ok: false,
           error: {
             code: "UNEXPECTED_CONTENT",
-            message: "is not supported but present",
-            expected: "X"
-          }
+            expected: "X",
+            message: "is not supported but present"
+          },
+          ok: false
         };
       }
       return { ok: true };
+    }
     case OptionalityCode.RequiredOrEmpty:
     case OptionalityCode.Optional:
     case OptionalityCode.Conditional:
     case OptionalityCode.BackwardCompatible:
-    case OptionalityCode.Withdrawn:
+    case OptionalityCode.Withdrawn: {
       return { ok: true };
-    default:
+    }
+    default: {
       return { ok: true };
+    }
   }
 }
 export {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/constants.ts","../src/utils.ts","../src/constraints.ts"],"sourcesContent":["// -------------\n// Delimiters\n// -------------\n\nexport const DEFAULT_DELIMITERS = {\n  field: \"|\",\n  component: \"^\",\n  repetition: \"~\",\n  subcomponent: \"&\",\n  escape: \"\\\\\",\n  segment: \"\\r\",\n};\n","import type { Nodes } from \"@rethinkhealth/hl7v2-ast\";\n\n// -------------\n// General\n// -------------\n\n/**\n * Utility: check if a node is semantically empty\n */\nexport function isEmptyNode(node: Nodes | null | undefined): boolean {\n  if (!node) {\n    return true;\n  }\n\n  // If node has a \"value\" property (Subcomponent, maybe Component)\n  if (\"value\" in node) {\n    return !node.value || node.value.trim() === \"\";\n  }\n\n  // If node has children (Field, Component, Repetition, Segment, Root, etc.)\n  if (\"children\" in node) {\n    if (!node.children || node.children.length === 0) {\n      return true;\n    }\n\n    // If node has more than one child, then it is considered non-empty\n    if (node.children.length > 1) {\n      return false;\n    }\n\n    // If node has only one child, then it is considered empty if the child is also empty\n    return isEmptyNode(node.children[0]);\n  }\n\n  // Fallback: consider unknown node as non-empty\n  return false;\n}\n\n// -------------\n// Byte Length\n// -------------\n\n/**\n * Calculate the byte length of any HL7v2 AST node.\n *\n * For literal nodes (Subcomponent, SegmentHeader), returns the UTF-8 byte length of the value.\n * For parent nodes, recursively calculates the length of all children. Delimiters are NOT included.\n *\n * @param node - The HL7v2 AST node to measure\n * @returns The total byte length of the node content\n *\n * @example\n * ```ts\n * const field: Field = { type: \"field\", children: [...] };\n * const length = getByteLength(field); // e.g., 42\n * ```\n */\nexport function getByteLength(node: Nodes | null | undefined): number {\n  if (!node) {\n    return 0;\n  }\n\n  if (\"value\" in node) {\n    return Buffer.byteLength(node.value, \"utf8\");\n  }\n\n  return node.children.reduce(\n    (total, child) => total + getByteLength(child),\n    0\n  );\n}\n\n// -------------\n// Length\n// -------------\n\n/**\n * Calculate the string length of any HL7v2 AST node.\n *\n * For literal nodes (Subcomponent, SegmentHeader), returns `value.length`.\n * For parent nodes, recursively calculates the length of all children. Delimiters are NOT included.\n *\n * Note: Returns JavaScript string length (UTF-16 code units). For UTF-8 byte\n * length (e.g., for wire protocol), use `getByteLength` instead.\n *\n * @param node - The HL7v2 AST node to measure\n * @returns The total string length of the node content\n *\n * @example\n * ```ts\n * const field: Field = { type: \"field\", children: [...] };\n * const length = getLength(field); // e.g., 42\n * ```\n */\nexport function getLength(node: Nodes | null | undefined): number {\n  if (!node) {\n    return 0;\n  }\n\n  if (\"value\" in node) {\n    return node.value.length;\n  }\n\n  return node.children.reduce((total, child) => total + getLength(child), 0);\n}\n","import type { Field, Nodes } from \"@rethinkhealth/hl7v2-ast\";\nimport { getLength, isEmptyNode } from \"./utils\";\n\nexport type ValidationErrorCode =\n  // Constraints\n  | \"MISSING\"\n  | \"EMPTY\"\n  | \"UNEXPECTED_CONTENT\"\n  | \"CARDINALITY_UNDERFLOW\"\n  | \"CARDINALITY_OVERFLOW\"\n  | \"LENGTH_UNDERFLOW\"\n  | \"LENGTH_OVERFLOW\"\n  // Value Sets\n  | \"VALUE_NOT_IN_TABLE\";\n\nexport type ValidationError = {\n  code: ValidationErrorCode;\n  message: string;\n  expected?: string | number | Array<string | number>;\n  actual?: string | number | Array<string | number>;\n};\n\nexport type ValidationSuccess = {\n  ok: true;\n};\n\nexport type ValidationFailure = {\n  ok: false;\n  error: ValidationError;\n};\n\nexport type ValidationResult = ValidationSuccess | ValidationFailure;\n\nexport const OptionalityCode = {\n  Required: \"R\",\n  /**\n   * Required, but may be empty.\n   *\n   * @remarks\n   * The use of the RE usage code is qualified with the “if data is known”\n   * clause. The sender must interpret the clause as “the capability must always\n   * be supported, and data must always be sent if known”. To clarify, the\n   * sender does not determine whether the data should be sent; to be conformant\n   * to the rule, the data must be sent. There is a misconception where the RE\n   * usage is interpreted as “the capability must always be supported, and data\n   * may or may not be sent even when known based on a condition external to the\n   * profile specification”.\n   *\n   * The receiving application must process in a meaningful way the information\n   * conveyed by an element with an “RE” usage designation.\n   * The receiving application must process the message if the element is omitted\n   * (that is, an exception must not be raised because the element is missing). A\n   * receiving application must not raise an exception due to the presence of a\n   * required element.\n   */\n  RequiredOrEmpty: \"RE\",\n  /**\n   * Optional\n   *\n   * There are no implementation requirements. The “O” usage designation is a\n   * placeholder indicating that the usage for this element has not yet been\n   * specified.\n   */\n  Optional: \"O\",\n  /**\n   * Undeclared / Conditional.\n   *\n   * There are no implementation requirements. The “C” usage designation is a\n   * placeholder indicating that the usage for this element has not yet been\n   * specified.\n   */\n  Conditional: \"C\",\n  /**\n   * Not Supported.\n   *\n   * There are no implementation requirements. The application must not value an\n   * element with an “X” usage designation.\n   */\n  NotSupported: \"X\",\n  /**\n   * Backward Compatible\n   *\n   * There are no implementation requirements. The “B” usage indicates that the\n   * element is retained for backwards compatibility of the element. Another\n   * usage indicator may be assigned in a derived profile.\n   */\n  BackwardCompatible: \"B\",\n  /**\n   * Withdrawn\n   *\n   * The element has been withdrawn from the standard. There are no\n   * implementation requirements. The application must not value an element with\n   * a \"W\" usage designation.\n   */\n  Withdrawn: \"W\",\n} as const;\n\nexport type OptionalityCode =\n  (typeof OptionalityCode)[keyof typeof OptionalityCode];\n\n/**\n * Checks if a field satisfies the cardinality constraint.\n */\nexport function checkCardinality(\n  node: Field | undefined,\n  min: number,\n  max: number | \"*\"\n): ValidationResult {\n  if (min < 0 || (max !== \"*\" && max < 0)) {\n    throw new Error(\"Min and max lengths must be non-negative\");\n  }\n\n  if (max !== \"*\" && min > max) {\n    throw new Error(\"Min length cannot be greater than max length\");\n  }\n\n  const count = node?.children ? node.children.length : 0;\n\n  if (count < min) {\n    return {\n      ok: false,\n      error: {\n        code: \"CARDINALITY_UNDERFLOW\",\n        message: `has ${count} repetitions but requires at least ${min}`,\n        expected: min,\n        actual: count,\n      },\n    };\n  }\n\n  if (max !== \"*\" && count > max) {\n    return {\n      ok: false,\n      error: {\n        code: \"CARDINALITY_OVERFLOW\",\n        message: `has ${count} repetitions but allows at most ${max}`,\n        expected: max,\n        actual: count,\n      },\n    };\n  }\n\n  return { ok: true };\n}\n\n/**\n * Checks if a node satisfies the length constraint.\n */\nexport function checkLength(\n  node: Nodes | undefined,\n  max: number,\n  min = 0\n): ValidationResult {\n  if (min < 0 || max < 0) {\n    throw new Error(\"Min and max lengths must be non-negative\");\n  }\n\n  if (min > max) {\n    throw new Error(\"Min length cannot be greater than max length\");\n  }\n\n  const length = getLength(node);\n\n  if (length < min) {\n    return {\n      ok: false,\n      error: {\n        code: \"LENGTH_UNDERFLOW\",\n        message: `has length ${length} but requires at least ${min}`,\n        expected: min,\n        actual: length,\n      },\n    };\n  }\n\n  if (length > max) {\n    return {\n      ok: false,\n      error: {\n        code: \"LENGTH_OVERFLOW\",\n        message: `has length ${length} but allows at most ${max}`,\n        expected: max,\n        actual: length,\n      },\n    };\n  }\n\n  return { ok: true };\n}\n\n/**\n * Checks if a node satisfies the optionality constraint.\n */\nexport function checkOptionality(\n  node: Nodes | undefined,\n  optionality: OptionalityCode | string\n): ValidationResult {\n  const code = optionality.toUpperCase();\n\n  switch (code) {\n    case OptionalityCode.Required:\n      if (!node) {\n        return {\n          ok: false,\n          error: {\n            code: \"MISSING\",\n            message: \"is required but missing\",\n            expected: \"R\",\n          },\n        };\n      }\n      if (isEmptyNode(node)) {\n        return {\n          ok: false,\n          error: {\n            code: \"EMPTY\",\n            message: \"is required but empty\",\n            expected: \"R\",\n          },\n        };\n      }\n      return { ok: true };\n\n    case OptionalityCode.NotSupported:\n      if (node && !isEmptyNode(node)) {\n        return {\n          ok: false,\n          error: {\n            code: \"UNEXPECTED_CONTENT\",\n            message: \"is not supported but present\",\n            expected: \"X\",\n          },\n        };\n      }\n      return { ok: true };\n\n    case OptionalityCode.RequiredOrEmpty:\n    case OptionalityCode.Optional:\n    case OptionalityCode.Conditional:\n    case OptionalityCode.BackwardCompatible:\n    case OptionalityCode.Withdrawn:\n      return { ok: true };\n\n    default:\n      return { ok: true };\n  }\n}\n"],"mappings":";AAIO,IAAM,qBAAqB;AAAA,EAChC,OAAO;AAAA,EACP,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,SAAS;AACX;;;ACFO,SAAS,YAAY,MAAyC;AACnE,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAGA,MAAI,WAAW,MAAM;AACnB,WAAO,CAAC,KAAK,SAAS,KAAK,MAAM,KAAK,MAAM;AAAA,EAC9C;AAGA,MAAI,cAAc,MAAM;AACtB,QAAI,CAAC,KAAK,YAAY,KAAK,SAAS,WAAW,GAAG;AAChD,aAAO;AAAA,IACT;AAGA,QAAI,KAAK,SAAS,SAAS,GAAG;AAC5B,aAAO;AAAA,IACT;AAGA,WAAO,YAAY,KAAK,SAAS,CAAC,CAAC;AAAA,EACrC;AAGA,SAAO;AACT;AAqBO,SAAS,cAAc,MAAwC;AACpE,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,MAAM;AACnB,WAAO,OAAO,WAAW,KAAK,OAAO,MAAM;AAAA,EAC7C;AAEA,SAAO,KAAK,SAAS;AAAA,IACnB,CAAC,OAAO,UAAU,QAAQ,cAAc,KAAK;AAAA,IAC7C;AAAA,EACF;AACF;AAwBO,SAAS,UAAU,MAAwC;AAChE,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,MAAM;AACnB,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,SAAO,KAAK,SAAS,OAAO,CAAC,OAAO,UAAU,QAAQ,UAAU,KAAK,GAAG,CAAC;AAC3E;;;ACvEO,IAAM,kBAAkB;AAAA,EAC7B,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqBV,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjB,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQV,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOb,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQd,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQpB,WAAW;AACb;AAQO,SAAS,iBACd,MACA,KACA,KACkB;AAClB,MAAI,MAAM,KAAM,QAAQ,OAAO,MAAM,GAAI;AACvC,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC5D;AAEA,MAAI,QAAQ,OAAO,MAAM,KAAK;AAC5B,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAEA,QAAM,QAAQ,MAAM,WAAW,KAAK,SAAS,SAAS;AAEtD,MAAI,QAAQ,KAAK;AACf,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,OAAO,KAAK,sCAAsC,GAAG;AAAA,QAC9D,UAAU;AAAA,QACV,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF;AAEA,MAAI,QAAQ,OAAO,QAAQ,KAAK;AAC9B,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,OAAO,KAAK,mCAAmC,GAAG;AAAA,QAC3D,UAAU;AAAA,QACV,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,IAAI,KAAK;AACpB;AAKO,SAAS,YACd,MACA,KACA,MAAM,GACY;AAClB,MAAI,MAAM,KAAK,MAAM,GAAG;AACtB,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC5D;AAEA,MAAI,MAAM,KAAK;AACb,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAEA,QAAM,SAAS,UAAU,IAAI;AAE7B,MAAI,SAAS,KAAK;AAChB,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,cAAc,MAAM,0BAA0B,GAAG;AAAA,QAC1D,UAAU;AAAA,QACV,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF;AAEA,MAAI,SAAS,KAAK;AAChB,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,cAAc,MAAM,uBAAuB,GAAG;AAAA,QACvD,UAAU;AAAA,QACV,QAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,IAAI,KAAK;AACpB;AAKO,SAAS,iBACd,MACA,aACkB;AAClB,QAAM,OAAO,YAAY,YAAY;AAErC,UAAQ,MAAM;AAAA,IACZ,KAAK,gBAAgB;AACnB,UAAI,CAAC,MAAM;AACT,eAAO;AAAA,UACL,IAAI;AAAA,UACJ,OAAO;AAAA,YACL,MAAM;AAAA,YACN,SAAS;AAAA,YACT,UAAU;AAAA,UACZ;AAAA,QACF;AAAA,MACF;AACA,UAAI,YAAY,IAAI,GAAG;AACrB,eAAO;AAAA,UACL,IAAI;AAAA,UACJ,OAAO;AAAA,YACL,MAAM;AAAA,YACN,SAAS;AAAA,YACT,UAAU;AAAA,UACZ;AAAA,QACF;AAAA,MACF;AACA,aAAO,EAAE,IAAI,KAAK;AAAA,IAEpB,KAAK,gBAAgB;AACnB,UAAI,QAAQ,CAAC,YAAY,IAAI,GAAG;AAC9B,eAAO;AAAA,UACL,IAAI;AAAA,UACJ,OAAO;AAAA,YACL,MAAM;AAAA,YACN,SAAS;AAAA,YACT,UAAU;AAAA,UACZ;AAAA,QACF;AAAA,MACF;AACA,aAAO,EAAE,IAAI,KAAK;AAAA,IAEpB,KAAK,gBAAgB;AAAA,IACrB,KAAK,gBAAgB;AAAA,IACrB,KAAK,gBAAgB;AAAA,IACrB,KAAK,gBAAgB;AAAA,IACrB,KAAK,gBAAgB;AACnB,aAAO,EAAE,IAAI,KAAK;AAAA,IAEpB;AACE,aAAO,EAAE,IAAI,KAAK;AAAA,EACtB;AACF;","names":[]}
+{"version":3,"sources":["../src/constants.ts","../src/utils.ts","../src/constraints.ts"],"sourcesContent":["// -------------\n// Delimiters\n// -------------\n\nexport const DEFAULT_DELIMITERS = {\n  component: \"^\",\n  escape: \"\\\\\",\n  field: \"|\",\n  repetition: \"~\",\n  segment: \"\\r\",\n  subcomponent: \"&\",\n};\n","import type { Nodes } from \"@rethinkhealth/hl7v2-ast\";\n\n// -------------\n// General\n// -------------\n\n/**\n * Utility: check if a node is semantically empty\n */\nexport function isEmptyNode(node?: Nodes | null | undefined): boolean {\n  if (!node) {\n    return true;\n  }\n\n  // If node has a \"value\" property (Subcomponent, maybe Component)\n  if (\"value\" in node) {\n    return !node.value || node.value.trim() === \"\";\n  }\n\n  // If node has children (Field, Component, Repetition, Segment, Root, etc.)\n  if (\"children\" in node) {\n    if (!node.children || node.children.length === 0) {\n      return true;\n    }\n\n    // If node has more than one child, then it is considered non-empty\n    if (node.children.length > 1) {\n      return false;\n    }\n\n    // If node has only one child, then it is considered empty if the child is also empty\n    return isEmptyNode(node.children[0]);\n  }\n\n  // Fallback: consider unknown node as non-empty\n  return false;\n}\n\n// -------------\n// Byte Length\n// -------------\n\n/**\n * Calculate the byte length of any HL7v2 AST node.\n *\n * For literal nodes (Subcomponent), returns the UTF-8 byte length of the value.\n * For parent nodes, recursively calculates the length of all children. Delimiters are NOT included.\n *\n * @param node - The HL7v2 AST node to measure\n * @returns The total byte length of the node content\n *\n * @example\n * ```ts\n * const field: Field = { type: \"field\", children: [...] };\n * const length = getByteLength(field); // e.g., 42\n * ```\n */\nexport function getByteLength(node?: Nodes | null | undefined): number {\n  if (!node) {\n    return 0;\n  }\n\n  if (\"value\" in node) {\n    return Buffer.byteLength(node.value, \"utf8\");\n  }\n\n  const nameLength =\n    node.type === \"segment\" ? Buffer.byteLength(node.name, \"utf8\") : 0;\n\n  return (\n    nameLength +\n    node.children.reduce((total, child) => total + getByteLength(child), 0)\n  );\n}\n\n// -------------\n// Length\n// -------------\n\n/**\n * Calculate the string length of any HL7v2 AST node.\n *\n * For literal nodes (Subcomponent), returns `value.length`.\n * For parent nodes, recursively calculates the length of all children. Delimiters are NOT included.\n *\n * Note: Returns JavaScript string length (UTF-16 code units). For UTF-8 byte\n * length (e.g., for wire protocol), use `getByteLength` instead.\n *\n * @param node - The HL7v2 AST node to measure\n * @returns The total string length of the node content\n *\n * @example\n * ```ts\n * const field: Field = { type: \"field\", children: [...] };\n * const length = getLength(field); // e.g., 42\n * ```\n */\nexport function getLength(node?: Nodes | null | undefined): number {\n  if (!node) {\n    return 0;\n  }\n\n  if (\"value\" in node) {\n    return node.value.length;\n  }\n\n  const nameLength = node.type === \"segment\" ? node.name.length : 0;\n\n  return (\n    nameLength +\n    node.children.reduce((total, child) => total + getLength(child), 0)\n  );\n}\n","import type { Field, Nodes } from \"@rethinkhealth/hl7v2-ast\";\n\nimport { getLength, isEmptyNode } from \"./utils\";\n\nexport type ValidationErrorCode =\n  // Constraints\n  | \"MISSING\"\n  | \"EMPTY\"\n  | \"UNEXPECTED_CONTENT\"\n  | \"CARDINALITY_UNDERFLOW\"\n  | \"CARDINALITY_OVERFLOW\"\n  | \"LENGTH_UNDERFLOW\"\n  | \"LENGTH_OVERFLOW\"\n  // Value Sets\n  | \"VALUE_NOT_IN_TABLE\";\n\nexport interface ValidationError {\n  code: ValidationErrorCode;\n  message: string;\n  expected?: string | number | Array<string | number>;\n  actual?: string | number | Array<string | number>;\n}\n\nexport interface ValidationSuccess {\n  ok: true;\n}\n\nexport interface ValidationFailure {\n  ok: false;\n  error: ValidationError;\n}\n\nexport type ValidationResult = ValidationSuccess | ValidationFailure;\n\nexport const OptionalityCode = {\n  /**\n   * Backward Compatible\n   *\n   * There are no implementation requirements. The “B” usage indicates that the\n   * element is retained for backwards compatibility of the element. Another\n   * usage indicator may be assigned in a derived profile.\n   */\n  BackwardCompatible: \"B\",\n\n  /**\n   * Undeclared / Conditional.\n   *\n   * There are no implementation requirements. The “C” usage designation is a\n   * placeholder indicating that the usage for this element has not yet been\n   * specified.\n   */\n  Conditional: \"C\",\n\n  /**\n   * Not Supported.\n   *\n   * There are no implementation requirements. The application must not value an\n   * element with an “X” usage designation.\n   */\n  NotSupported: \"X\",\n\n  /**\n   * Optional\n   *\n   * There are no implementation requirements. The “O” usage designation is a\n   * placeholder indicating that the usage for this element has not yet been\n   * specified.\n   */\n  Optional: \"O\",\n\n  /**\n   * Required\n   */\n  Required: \"R\",\n\n  /**\n   * Required, but may be empty.\n   *\n   * The use of the RE usage code is qualified with the “if data is known”\n   * clause. The sender must interpret the clause as “the capability must always\n   * be supported, and data must always be sent if known”. To clarify, the\n   * sender does not determine whether the data should be sent; to be conformant\n   * to the rule, the data must be sent. There is a misconception where the RE\n   * usage is interpreted as “the capability must always be supported, and data\n   * may or may not be sent even when known based on a condition external to the\n   * profile specification”.\n   *\n   * The receiving application must process in a meaningful way the information\n   * conveyed by an element with an “RE” usage designation.\n   * The receiving application must process the message if the element is omitted\n   * (that is, an exception must not be raised because the element is missing). A\n   * receiving application must not raise an exception due to the presence of a\n   * required element.\n   */\n  RequiredOrEmpty: \"RE\",\n\n  /**\n   * Withdrawn\n   *\n   * The element has been withdrawn from the standard. There are no\n   * implementation requirements. The application must not value an element with\n   * a \"W\" usage designation.\n   */\n  Withdrawn: \"W\",\n} as const;\n\nexport type OptionalityCode =\n  (typeof OptionalityCode)[keyof typeof OptionalityCode];\n\n/**\n * Checks if a field satisfies the cardinality constraint.\n */\nexport function checkCardinality(\n  node: Field | undefined,\n  min: number,\n  max: number | \"*\"\n): ValidationResult {\n  if (min < 0 || (max !== \"*\" && max < 0)) {\n    throw new Error(\"Min and max lengths must be non-negative\");\n  }\n\n  if (max !== \"*\" && min > max) {\n    throw new Error(\"Min length cannot be greater than max length\");\n  }\n\n  const count = node?.children ? node.children.length : 0;\n\n  if (count < min) {\n    return {\n      error: {\n        actual: count,\n        code: \"CARDINALITY_UNDERFLOW\",\n        expected: min,\n        message: `has ${count} repetitions but requires at least ${min}`,\n      },\n      ok: false,\n    };\n  }\n\n  if (max !== \"*\" && count > max) {\n    return {\n      error: {\n        actual: count,\n        code: \"CARDINALITY_OVERFLOW\",\n        expected: max,\n        message: `has ${count} repetitions but allows at most ${max}`,\n      },\n      ok: false,\n    };\n  }\n\n  return { ok: true };\n}\n\n/**\n * Checks if a node satisfies the length constraint.\n */\nexport function checkLength(\n  node: Nodes | undefined,\n  max: number,\n  min = 0\n): ValidationResult {\n  if (min < 0 || max < 0) {\n    throw new Error(\"Min and max lengths must be non-negative\");\n  }\n\n  if (min > max) {\n    throw new Error(\"Min length cannot be greater than max length\");\n  }\n\n  const length = getLength(node);\n\n  if (length < min) {\n    return {\n      error: {\n        actual: length,\n        code: \"LENGTH_UNDERFLOW\",\n        expected: min,\n        message: `has length ${length} but requires at least ${min}`,\n      },\n      ok: false,\n    };\n  }\n\n  if (length > max) {\n    return {\n      error: {\n        actual: length,\n        code: \"LENGTH_OVERFLOW\",\n        expected: max,\n        message: `has length ${length} but allows at most ${max}`,\n      },\n      ok: false,\n    };\n  }\n\n  return { ok: true };\n}\n\n/**\n * Checks if a node satisfies the optionality constraint.\n */\nexport function checkOptionality(\n  node: Nodes | undefined,\n  optionality: OptionalityCode | string\n): ValidationResult {\n  const code = optionality.toUpperCase();\n\n  switch (code) {\n    case OptionalityCode.Required: {\n      if (!node) {\n        return {\n          error: {\n            code: \"MISSING\",\n            expected: \"R\",\n            message: \"is required but missing\",\n          },\n          ok: false,\n        };\n      }\n      if (isEmptyNode(node)) {\n        return {\n          error: {\n            code: \"EMPTY\",\n            expected: \"R\",\n            message: \"is required but empty\",\n          },\n          ok: false,\n        };\n      }\n      return { ok: true };\n    }\n\n    case OptionalityCode.NotSupported: {\n      if (node && !isEmptyNode(node)) {\n        return {\n          error: {\n            code: \"UNEXPECTED_CONTENT\",\n            expected: \"X\",\n            message: \"is not supported but present\",\n          },\n          ok: false,\n        };\n      }\n      return { ok: true };\n    }\n\n    case OptionalityCode.RequiredOrEmpty:\n    case OptionalityCode.Optional:\n    case OptionalityCode.Conditional:\n    case OptionalityCode.BackwardCompatible:\n    case OptionalityCode.Withdrawn: {\n      return { ok: true };\n    }\n\n    default: {\n      return { ok: true };\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/utils.d.ts

@@ -2,11 +2,11 @@ import type { Nodes } from "@rethinkhealth/hl7v2-ast";
 /**
  * Utility: check if a node is semantically empty
  */
-export declare function isEmptyNode(node: Nodes | null | undefined): boolean;
+export declare function isEmptyNode(node?: Nodes | null | undefined): boolean;
 /**
  * Calculate the byte length of any HL7v2 AST node.
  *
- * For literal nodes (Subcomponent, SegmentHeader), returns the UTF-8 byte length of the value.
+ * For literal nodes (Subcomponent), returns the UTF-8 byte length of the value.
  * For parent nodes, recursively calculates the length of all children. Delimiters are NOT included.
  *
  * @param node - The HL7v2 AST node to measure
@@ -18,11 +18,11 @@ export declare function isEmptyNode(node: Nodes | null | undefined): boolean;
  * const length = getByteLength(field); // e.g., 42
  * ```
  */
-export declare function getByteLength(node: Nodes | null | undefined): number;
+export declare function getByteLength(node?: Nodes | null | undefined): number;
 /**
  * Calculate the string length of any HL7v2 AST node.
  *
- * For literal nodes (Subcomponent, SegmentHeader), returns `value.length`.
+ * For literal nodes (Subcomponent), returns `value.length`.
  * For parent nodes, recursively calculates the length of all children. Delimiters are NOT included.
  *
  * Note: Returns JavaScript string length (UTF-16 code units). For UTF-8 byte
@@ -37,5 +37,5 @@ export declare function getByteLength(node: Nodes | null | undefined): number;
  * const length = getLength(field); // e.g., 42
  * ```
  */
-export declare function getLength(node: Nodes | null | undefined): number;
+export declare function getLength(node?: Nodes | null | undefined): number;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAMtD;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CA2BnE;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAapE;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAUhE"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAMtD;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CA2BpE;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAgBrE;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAejE"}

package/package.json

@@ -1,50 +1,50 @@
 {
   "name": "@rethinkhealth/hl7v2-utils",
+  "version": "0.5.0",
   "description": "hl7v2 utilities",
-  "version": "0.4.2",
+  "keywords": [
+    "health",
+    "healthcare",
+    "hl7",
+    "hl7v2",
+    "nodejs",
+    "typescript"
+  ],
+  "homepage": "https://www.rethinkhealth.io/hl7v2/docs",
   "license": "MIT",
   "author": {
     "name": "Melek Somai",
     "email": "melek@rethinkhealth.io"
   },
-  "type": "module",
-  "types": "./dist/index.d.ts",
+  "repository": "rethinkhealth/hl7v2.git",
   "files": [
     "dist"
   ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
     "@types/node": "24.10.1",
     "@types/unist": "^3.0.3",
-    "@vitest/coverage-v8": "4.0.14",
+    "@vitest/coverage-v8": "4.0.18",
     "tsup": "8.5.1",
     "typescript": "^5.9.3",
     "unist-builder": "^4.0.0",
     "vfile": "^6.0.3",
     "vitest": "4.0.14",
-    "@rethinkhealth/hl7v2-ast": "0.4.2",
+    "@rethinkhealth/hl7v2-ast": "0.5.0",
     "@rethinkhealth/testing": "0.0.2",
     "@rethinkhealth/tsconfig": "0.0.1"
   },
   "engines": {
     "node": ">=18"
   },
-  "repository": "rethinkhealth/hl7v2.git",
-  "homepage": "https://www.rethinkhealth.io/hl7v2/docs",
-  "keywords": [
-    "health",
-    "healthcare",
-    "hl7",
-    "hl7v2",
-    "nodejs",
-    "typescript"
-  ],
   "packageManager": "pnpm@10.14.0",
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
     "build": "tsup && tsc --emitDeclarationOnly",
     "check-types": "tsc --noEmit",