@glion/lint-profile-field-max-length 0.23.0 → 0.24.0

package/README.md

@@ -1,10 +1,10 @@
 # @glion/lint-profile-field-max-length
 
-Lint rule to validate field value lengths against HL7v2 profile maxLength.
+Lint rule that reports a field value longer than HL7v2 allows.
 
 ## What it does
 
-Flags field values that exceed the `maxLength` declared in the HL7v2 profile for the message's version. Length is computed by recursively summing the string lengths of all subcomponent values in a repetition, so delimiters (`^`, `&`, `~`) are not counted. The rule reads profile context attached by `@glion/annotate-profile-context` and reports once per offending repetition. Fields without a declared `maxLength`, empty fields, and Z-segments are skipped.
+Flags a field value longer than the maximum length the HL7v2 standard gives that field in the message's version. Each repetition of a field is measured on its own, and delimiters (`^`, `&`) are not counted. It needs the plugins `@glion/annotate-profile-context` and `@glion/annotate-profile-fields` to run before it; `@glion/preset-lint-profile-recommended` includes them.
 
 ## Install
 
@@ -16,21 +16,24 @@ npm install @glion/lint-profile-field-max-length
 
 ```ts
 import { hl7v2AnnotateProfileContext } from "@glion/annotate-profile-context";
-import { hl7v2Parser } from "@glion/parser";
+import { hl7v2AnnotateProfileFields } from "@glion/annotate-profile-fields";
 import hl7v2LintFieldMaxLength from "@glion/lint-profile-field-max-length";
+import { parseHL7v2 } from "@glion/parser";
 import { unified } from "unified";
+import { VFile } from "vfile";
 import { reporter } from "vfile-reporter";
 
 const message = [
-  "MSH|^~\\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5",
+  "MSH|^~\\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG0000000000000000000000001|P|2.5",
   "PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F",
 ].join("\r");
 
-const file = await unified()
-  .use(hl7v2Parser)
+const file = new VFile();
+await unified()
   .use(hl7v2AnnotateProfileContext)
+  .use(hl7v2AnnotateProfileFields)
   .use(hl7v2LintFieldMaxLength)
-  .process(message);
+  .run(parseHL7v2(message), file);
 
 console.error(reporter([file]));
 ```
@@ -39,9 +42,7 @@ console.error(reporter([file]));
 
 ### `unified().use(hl7v2LintFieldMaxLength)`
 
-A `unified` lint rule plugin. Takes no options.
-
-Reads `file.data.profile`. For each segment in the tree it walks its fields, looks up the profile entry by sequence, and — if a `maxLength` is declared — compares it against `getLength()` from `@glion/utils` for every repetition. Each repetition over the limit produces one message.
+A `unified` lint rule plugin. Takes no options. Reports one message for each field repetition over the limit.
 
 ```ts
 import type { Plugin } from "unified";
@@ -53,11 +54,11 @@ export default hl7v2LintFieldMaxLength;
 
 ## What it checks
 
-This rule flags fields whose measured content length is greater than the `maxLength` declared for that field in the HL7v2 profile. In v2.5, `MSH-10` (Message Control ID) has `maxLength: 20`.
+Each repetition of a field is at most as long as the field's maximum length in the message's version. For example, `MSH-10` (Message Control ID) allows 20 characters in v2.5.
 
 ### Valid
 
-`MSH-10` carries a 9-character Message Control ID, well within the v2.5 limit of 20:
+`MSH-10` has 8 characters:
 
 ```hl7
 MSH|^~\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG00001|P|2.5
@@ -66,7 +67,7 @@ PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F
 
 ### Invalid
 
-`MSH-10` is 28 characters long, exceeding the v2.5 limit of 20:
+`MSH-10` has 28 characters:
 
 ```hl7
 MSH|^~\&|SENDER|FAC|RECV|RFAC|20250601120000||ADT^A01^ADT_A01|MSG0000000000000000000000001|P|2.5
@@ -76,10 +77,10 @@ PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F
 Reported message:
 
 ```
-Field MSH-10 exceeds max length of 20 (actual: 28)
+Field `MSH-10` (Message Control ID) is 28 characters long; it allows at most 20 characters.
 ```
 
-One message is produced per offending repetition. Delimiters are not included in the measured length — a composite value like `DOE^JANE` counts as 7 characters, not 8.
+A composite value such as `DOE^JANE` counts as 7 characters, not 8.
 
 ## Part of Glion
 

package/dist/index.d.ts

@@ -1,20 +1,17 @@
 import type { Root } from "@glion/ast";
 /**
- * Lint rule that validates field value lengths against HL7v2 profile maxLength.
+ * Lint rule that reports a field repetition longer than the field's LEN.
  *
- * For each field with a defined `maxLength` in the profile, checks that
- * each repetition's content length does not exceed the limit.
- *
- * The length is measured using `getLength()` from `hl7v2-utils`, which
- * recursively sums the string lengths of all subcomponent values.
- * Delimiters are not included in the count.
- *
- * Fields without `maxLength` in the profile and empty fields are skipped.
- * Segments without a known profile (e.g., Z-segments) are silently skipped.
+ * Reads `maxLength` from `field.data`, so `@glion/annotate-profile-fields`
+ * MUST run before it. The length of a repetition is the sum of its values,
+ * delimiters excluded.
  *
  * @example
  *   ```typescript
- *   unified().use(hl7v2LintFieldMaxLength);
+ *   unified()
+ *     .use(hl7v2AnnotateProfileContext)
+ *     .use(hl7v2AnnotateProfileFields)
+ *     .use(hl7v2LintFieldMaxLength);
  *   ```;
  */
 declare const hl7v2LintFieldMaxLength: import("unified-lint-rule").Plugin<Root, unknown>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAKvC;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,uBAAuB,mDAqD5B,CAAC;AAEF,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAWvC;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,uBAAuB,mDA8B5B,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,50 +1,46 @@
 import { SKIP, visit } from "@glion/util-visit";
-import { getLength, isEmptyNode } from "@glion/utils";
+import { getLength } from "@glion/utils";
+import pluralize from "pluralize";
 import { lintRule } from "unified-lint-rule";
 //#region src/index.ts
+const messages = { tooLong: (field, name, length, max) => `Field \`${field}\` (${name}) is ${pluralize("character", length, true)} long; it allows at most ${pluralize("character", max, true)}.` };
 /**
-* Lint rule that validates field value lengths against HL7v2 profile maxLength.
+* Lint rule that reports a field repetition longer than the field's LEN.
 *
-* For each field with a defined `maxLength` in the profile, checks that
-* each repetition's content length does not exceed the limit.
-*
-* The length is measured using `getLength()` from `hl7v2-utils`, which
-* recursively sums the string lengths of all subcomponent values.
-* Delimiters are not included in the count.
-*
-* Fields without `maxLength` in the profile and empty fields are skipped.
-* Segments without a known profile (e.g., Z-segments) are silently skipped.
+* Reads `maxLength` from `field.data`, so `@glion/annotate-profile-fields`
+* MUST run before it. The length of a repetition is the sum of its values,
+* delimiters excluded.
 *
 * @example
 *   ```typescript
-*   unified().use(hl7v2LintFieldMaxLength);
+*   unified()
+*     .use(hl7v2AnnotateProfileContext)
+*     .use(hl7v2AnnotateProfileFields)
+*     .use(hl7v2LintFieldMaxLength);
 *   ```;
 */
-const hl7v2LintFieldMaxLength = lintRule({ origin: "hl7v2-lint:field-max-length" }, (tree, file) => {
-	const ctx = file.data.profile;
-	if (!ctx) return;
-	visit(tree, "segment", (segment, segmentAncestors) => {
-		const fieldDef = ctx.fields.get(segment.name);
-		if (!fieldDef) return SKIP;
-		visit(segment, "field", (fieldNode, _fieldAncestors, info) => {
-			if (isEmptyNode(fieldNode)) return SKIP;
-			const profile = fieldDef.bySequence.get(info.sequence);
-			if (!profile?.maxLength) return SKIP;
-			for (const repetition of fieldNode.children) {
-				const len = getLength(repetition);
-				if (len === 0) continue;
-				if (len > profile.maxLength) file.message(`Field ${segment.name}-${info.sequence} exceeds max length of ${profile.maxLength} (actual: ${len})`, {
+const hl7v2LintFieldMaxLength = lintRule({
+	origin: "hl7v2-lint:field-max-length",
+	url: "https://github.com/rethinkhealth/glion/tree/main/packages/lint-profile-field-max-length#readme"
+}, (tree, file) => {
+	visit(tree, "field", (field, ancestors) => {
+		const id = field.data?.id;
+		const maxLength = field.data?.maxLength;
+		if (id === void 0 || maxLength === void 0) return SKIP;
+		for (const repetition of field.children) {
+			const length = getLength(repetition);
+			if (length > maxLength) {
+				const message = file.message(messages.tooLong(id, field.data?.name ?? "", length, maxLength), {
 					ancestors: [
-						...segmentAncestors,
-						segment,
-						fieldNode,
+						...ancestors,
+						field,
 						repetition
 					],
-					place: repetition.position ?? fieldNode.position
+					place: repetition.position ?? field.position
 				});
+				message.actual = String(length);
 			}
-			return SKIP;
-		});
+		}
 		return SKIP;
 	});
 });

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["// oxlint-disable-next-line no-unused-vars -- triggers VFile DataMap augmentation\nimport type { ProfileContext } from \"@glion/annotate-profile-context\";\nimport type { Root } from \"@glion/ast\";\nimport { SKIP, visit } from \"@glion/util-visit\";\nimport { getLength, isEmptyNode } from \"@glion/utils\";\nimport { lintRule } from \"unified-lint-rule\";\n\n/**\n * Lint rule that validates field value lengths against HL7v2 profile maxLength.\n *\n * For each field with a defined `maxLength` in the profile, checks that\n * each repetition's content length does not exceed the limit.\n *\n * The length is measured using `getLength()` from `hl7v2-utils`, which\n * recursively sums the string lengths of all subcomponent values.\n * Delimiters are not included in the count.\n *\n * Fields without `maxLength` in the profile and empty fields are skipped.\n * Segments without a known profile (e.g., Z-segments) are silently skipped.\n *\n * @example\n *   ```typescript\n *   unified().use(hl7v2LintFieldMaxLength);\n *   ```;\n */\nconst hl7v2LintFieldMaxLength = lintRule<Root>(\n  { origin: \"hl7v2-lint:field-max-length\" },\n  (tree, file) => {\n    const ctx = file.data.profile;\n    if (!ctx) {\n      return;\n    }\n\n    visit(tree, \"segment\", (segment, segmentAncestors) => {\n      const fieldDef = ctx.fields.get(segment.name);\n      if (!fieldDef) {\n        return SKIP;\n      }\n\n      visit(segment, \"field\", (fieldNode, _fieldAncestors, info) => {\n        if (isEmptyNode(fieldNode)) {\n          return SKIP;\n        }\n\n        const profile = fieldDef.bySequence.get(info.sequence);\n\n        if (!profile?.maxLength) {\n          return SKIP;\n        }\n\n        for (const repetition of fieldNode.children) {\n          const len = getLength(repetition);\n          if (len === 0) {\n            continue;\n          }\n\n          if (len > profile.maxLength) {\n            file.message(\n              `Field ${segment.name}-${info.sequence} exceeds max length of ${profile.maxLength} (actual: ${len})`,\n              {\n                ancestors: [\n                  ...segmentAncestors,\n                  segment,\n                  fieldNode,\n                  repetition,\n                ],\n                place: repetition.position ?? fieldNode.position,\n              }\n            );\n          }\n        }\n\n        return SKIP;\n      });\n\n      return SKIP;\n    });\n  }\n);\n\nexport default hl7v2LintFieldMaxLength;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,0BAA0B,SAC9B,EAAE,QAAQ,+BAA+B,GACxC,MAAM,SAAS;CACd,MAAM,MAAM,KAAK,KAAK;AACtB,KAAI,CAAC,IACH;AAGF,OAAM,MAAM,YAAY,SAAS,qBAAqB;EACpD,MAAM,WAAW,IAAI,OAAO,IAAI,QAAQ,KAAK;AAC7C,MAAI,CAAC,SACH,QAAO;AAGT,QAAM,SAAS,UAAU,WAAW,iBAAiB,SAAS;AAC5D,OAAI,YAAY,UAAU,CACxB,QAAO;GAGT,MAAM,UAAU,SAAS,WAAW,IAAI,KAAK,SAAS;AAEtD,OAAI,CAAC,SAAS,UACZ,QAAO;AAGT,QAAK,MAAM,cAAc,UAAU,UAAU;IAC3C,MAAM,MAAM,UAAU,WAAW;AACjC,QAAI,QAAQ,EACV;AAGF,QAAI,MAAM,QAAQ,UAChB,MAAK,QACH,SAAS,QAAQ,KAAK,GAAG,KAAK,SAAS,yBAAyB,QAAQ,UAAU,YAAY,IAAI,IAClG;KACE,WAAW;MACT,GAAG;MACH;MACA;MACA;MACD;KACD,OAAO,WAAW,YAAY,UAAU;KACzC,CACF;;AAIL,UAAO;IACP;AAEF,SAAO;GACP;EAEL"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["// oxlint-disable-next-line no-unused-vars -- triggers FieldData augmentation\nimport type { hl7v2AnnotateProfileFields } from \"@glion/annotate-profile-fields\";\nimport type { Root } from \"@glion/ast\";\nimport { SKIP, visit } from \"@glion/util-visit\";\nimport { getLength } from \"@glion/utils\";\nimport pluralize from \"pluralize\";\nimport { lintRule } from \"unified-lint-rule\";\n\nconst messages = {\n  tooLong: (field: string, name: string, length: number, max: number) =>\n    `Field \\`${field}\\` (${name}) is ${pluralize(\"character\", length, true)} long; it allows at most ${pluralize(\"character\", max, true)}.`,\n} as const;\n\n/**\n * Lint rule that reports a field repetition longer than the field's LEN.\n *\n * Reads `maxLength` from `field.data`, so `@glion/annotate-profile-fields`\n * MUST run before it. The length of a repetition is the sum of its values,\n * delimiters excluded.\n *\n * @example\n *   ```typescript\n *   unified()\n *     .use(hl7v2AnnotateProfileContext)\n *     .use(hl7v2AnnotateProfileFields)\n *     .use(hl7v2LintFieldMaxLength);\n *   ```;\n */\nconst hl7v2LintFieldMaxLength = lintRule<Root>(\n  {\n    origin: \"hl7v2-lint:field-max-length\",\n    url: \"https://github.com/rethinkhealth/glion/tree/main/packages/lint-profile-field-max-length#readme\",\n  },\n  (tree, file) => {\n    visit(tree, \"field\", (field, ancestors) => {\n      const id = field.data?.id;\n      const maxLength = field.data?.maxLength;\n      if (id === undefined || maxLength === undefined) {\n        return SKIP;\n      }\n\n      // HL7v2 applies LEN to each repetition, not to the whole field.\n      for (const repetition of field.children) {\n        const length = getLength(repetition);\n        if (length > maxLength) {\n          const message = file.message(\n            messages.tooLong(id, field.data?.name ?? \"\", length, maxLength),\n            {\n              ancestors: [...ancestors, field, repetition],\n              place: repetition.position ?? field.position,\n            }\n          );\n          message.actual = String(length);\n        }\n      }\n      return SKIP;\n    });\n  }\n);\n\nexport default hl7v2LintFieldMaxLength;\n"],"mappings":";;;;;AAQA,MAAM,WAAW,EACf,UAAU,OAAe,MAAc,QAAgB,QACrD,WAAW,MAAM,MAAM,KAAK,OAAO,UAAU,aAAa,QAAQ,KAAK,CAAC,2BAA2B,UAAU,aAAa,KAAK,KAAK,CAAC,IACxI;;;;;;;;;;;;;;;;AAiBD,MAAM,0BAA0B,SAC9B;CACE,QAAQ;CACR,KAAK;CACN,GACA,MAAM,SAAS;AACd,OAAM,MAAM,UAAU,OAAO,cAAc;EACzC,MAAM,KAAK,MAAM,MAAM;EACvB,MAAM,YAAY,MAAM,MAAM;AAC9B,MAAI,OAAO,KAAA,KAAa,cAAc,KAAA,EACpC,QAAO;AAIT,OAAK,MAAM,cAAc,MAAM,UAAU;GACvC,MAAM,SAAS,UAAU,WAAW;AACpC,OAAI,SAAS,WAAW;IACtB,MAAM,UAAU,KAAK,QACnB,SAAS,QAAQ,IAAI,MAAM,MAAM,QAAQ,IAAI,QAAQ,UAAU,EAC/D;KACE,WAAW;MAAC,GAAG;MAAW;MAAO;MAAW;KAC5C,OAAO,WAAW,YAAY,MAAM;KACrC,CACF;AACD,YAAQ,SAAS,OAAO,OAAO;;;AAGnC,SAAO;GACP;EAEL"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glion/lint-profile-field-max-length",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Lint rule to validate field value lengths against HL7v2 profile maxLength",
   "keywords": [
     "health",
@@ -33,13 +33,16 @@
     "access": "public"
   },
   "dependencies": {
+    "pluralize": "8.0.0",
     "unified-lint-rule": "3.0.1",
-    "@glion/ast": "0.23.0",
-    "@glion/util-visit": "0.23.0",
-    "@glion/utils": "0.23.0"
+    "@glion/util-visit": "0.24.0",
+    "@glion/annotate-profile-fields": "0.24.0",
+    "@glion/utils": "0.24.0",
+    "@glion/ast": "0.24.0"
   },
   "devDependencies": {
     "@types/node": "25.6.0",
+    "@types/pluralize": "^0.0.33",
     "@vitest/coverage-v8": "4.1.11",
     "publint": "0.3.18",
     "tsdown": "0.21.10",
@@ -47,11 +50,12 @@
     "unified": "^11.0.5",
     "vfile": "^6.0.3",
     "vitest": "4.1.11",
-    "@glion/annotate-profile-context": "0.23.0",
-    "@glion/builder": "0.23.0",
+    "@glion/builder": "0.24.0",
+    "@glion/annotate-profile-context": "0.24.0",
     "@glion/check-readme": "0.18.0",
     "@glion/testing": "0.18.0",
-    "@glion/tsconfig": "0.18.0"
+    "@glion/tsconfig": "0.18.0",
+    "@glion/parser": "0.24.0"
   },
   "engines": {
     "node": ">=22"