@glion/lint-profile-extra-components 0.22.0 → 0.24.0

package/README.md

@@ -4,7 +4,7 @@ Lint rule to warn when a composite field contains more components than its datat
 
 ## What it does
 
-Flags fields whose repetitions contain more components than the datatype's profile allows. For composite datatypes, the maximum is the highest sequence key in the datatype definition; for primitive datatypes the maximum is 1 (the value itself). The rule reads profile context attached by `@glion/annotate-profile-context`. Empty fields, fields on unknown segments, and fields whose datatype definition is missing are silently skipped.
+Flags a field repetition with more components than its datatype defines in the message's version. A primitive datatype defines one component. Empty fields, fields on unknown segments, and fields with no datatype are skipped. 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,6 +16,7 @@ npm install @glion/lint-profile-extra-components
 
 ```ts
 import { hl7v2AnnotateProfileContext } from "@glion/annotate-profile-context";
+import { hl7v2AnnotateProfileFields } from "@glion/annotate-profile-fields";
 import { hl7v2Parser } from "@glion/parser";
 import hl7v2LintExtraComponents from "@glion/lint-profile-extra-components";
 import { unified } from "unified";
@@ -29,6 +30,7 @@ const message = [
 const file = await unified()
   .use(hl7v2Parser)
   .use(hl7v2AnnotateProfileContext)
+  .use(hl7v2AnnotateProfileFields)
   .use(hl7v2LintExtraComponents)
   .process(message);
 
@@ -39,9 +41,7 @@ console.error(reporter([file]));
 
 ### `unified().use(hl7v2LintExtraComponents)`
 
-A `unified` lint rule plugin. Takes no options.
-
-Reads `file.data.profile`. For each non-empty field it resolves the datatype definition. For primitives the allowed component count is 1; for composites it is the highest key in `dtDef.componentsBySequence`. Every component at a position greater than that max produces one message per offending repetition.
+A `unified` lint rule plugin. Takes no options. Reports one message for each repetition with too many components, with the number of components in `actual`.
 
 ```ts
 import type { Plugin } from "unified";
@@ -53,7 +53,7 @@ export default hl7v2LintExtraComponents;
 
 ## What it checks
 
-This rule flags `^`-delimited components past the profile's defined range for a datatype. `PID-8` (Administrative Sex) is a primitive field in v2.5, so it allows exactly one component.
+A field repetition has at most as many components as its datatype defines. `PID-8` (Administrative Sex) is a primitive field in v2.5, so it allows one component.
 
 ### Valid
 
@@ -76,10 +76,14 @@ PID|1||PATID1234^^^HOSP^MR||DOE^JANE||19800101|F^EXTRA
 Reported message:
 
 ```
-Component PID-8.2 is beyond the defined components for IS (max: 1 in v2.5)
+Field `PID-8` (Administrative Sex) has 2 components; it allows at most 1 component.
 ```
 
-The datatype code (for example `IS`, `CX`, `XPN`) comes from the field's profile. For composite datatypes the same rule applies — a `CX` field in v2.5 defines up to 10 components, so a value carrying an 11th is reported against that datatype.
+The limit comes from the field's datatype in the message's version. `PID-3` is a `CX` field, which defines 10 components in v2.5, so a repetition with 11 is reported as:
+
+```
+Field `PID-3` (Patient Identifier List) has 11 components; it allows at most 10 components.
+```
 
 ## Part of Glion
 

package/dist/index.d.ts

@@ -1,18 +1,19 @@
 import type { Root } from "@glion/ast";
 /**
- * Lint rule that warns when a field contains more components than its
- * datatype profile defines.
+ * Lint rule that reports a field repetition with more components than its
+ * datatype defines.
  *
- * For composite datatypes, checks against the defined component count.
- * For primitive datatypes, the maximum is 1 — any additional components
- * are flagged as extra.
+ * A primitive datatype defines one component. Empty fields are not checked.
  *
- * Empty fields are skipped.
- * Segments without a known profile (e.g., Z-segments) are silently skipped.
+ * Reads `id` and `datatype` from `field.data`, so
+ * `@glion/annotate-profile-fields` MUST run before it.
  *
  * @example
  *   ```typescript
- *   unified().use(hl7v2LintExtraComponents);
+ *   unified()
+ *     .use(hl7v2AnnotateProfileContext)
+ *     .use(hl7v2AnnotateProfileFields)
+ *     .use(hl7v2LintExtraComponents);
  *   ```;
  */
 declare const hl7v2LintExtraComponents: 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,EAAS,IAAI,EAAW,MAAM,YAAY,CAAC;AAKvD;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,wBAAwB,mDA0D7B,CAAC;AAaF,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAgBvC;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,wBAAwB,mDAwC7B,CAAC;AAEF,eAAe,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,55 +1,55 @@
 import { SKIP, visit } from "@glion/util-visit";
 import { isEmptyNode } from "@glion/utils";
+import pluralize from "pluralize";
 import { lintRule } from "unified-lint-rule";
 //#region src/index.ts
+const messages = { tooManyComponents: (field, name, count, max) => `Field \`${field}\` (${name}) has ${pluralize("component", count, true)}; it allows at most ${pluralize("component", max, true)}.` };
 /**
-* Lint rule that warns when a field contains more components than its
-* datatype profile defines.
+* Lint rule that reports a field repetition with more components than its
+* datatype defines.
 *
-* For composite datatypes, checks against the defined component count.
-* For primitive datatypes, the maximum is 1 — any additional components
-* are flagged as extra.
+* A primitive datatype defines one component. Empty fields are not checked.
 *
-* Empty fields are skipped.
-* Segments without a known profile (e.g., Z-segments) are silently skipped.
+* Reads `id` and `datatype` from `field.data`, so
+* `@glion/annotate-profile-fields` MUST run before it.
 *
 * @example
 *   ```typescript
-*   unified().use(hl7v2LintExtraComponents);
+*   unified()
+*     .use(hl7v2AnnotateProfileContext)
+*     .use(hl7v2AnnotateProfileFields)
+*     .use(hl7v2LintExtraComponents);
 *   ```;
 */
-const hl7v2LintExtraComponents = lintRule({ origin: "hl7v2-lint:extra-components" }, (tree, file) => {
+const hl7v2LintExtraComponents = lintRule({
+	origin: "hl7v2-lint:extra-components",
+	url: "https://github.com/rethinkhealth/glion/tree/main/packages/lint-profile-extra-components#readme"
+}, (tree, file) => {
 	const ctx = file.data.profile;
 	if (!ctx) return;
-	visit(tree, "field", (fieldNode, ancestors, info) => {
-		if (isEmptyNode(fieldNode)) return SKIP;
-		const segment = ancestors.at(-1);
-		if (!segment || segment.type !== "segment") return SKIP;
-		const fieldDef = ctx.fields.get(segment.name);
-		if (!fieldDef) return SKIP;
-		const fieldProfile = fieldDef.bySequence.get(info.sequence);
-		if (!fieldProfile) return SKIP;
-		const dtDef = ctx.datatypes.get(fieldProfile.datatype);
-		if (!dtDef) return SKIP;
-		const maxComponent = dtDef.kind === "primitive" ? 1 : maxKey(dtDef.componentsBySequence);
-		if (maxComponent === 0) return SKIP;
-		for (const repetition of fieldNode.children) for (let i = maxComponent + 1; i <= repetition.children.length; i++) file.message(`Component ${segment.name}-${info.sequence}.${i} is beyond the defined components for ${fieldProfile.datatype} (max: ${maxComponent} in v${ctx.version})`, {
-			ancestors: [
-				...ancestors,
-				fieldNode,
-				repetition
-			],
-			place: repetition.position ?? fieldNode.position
-		});
+	visit(tree, "field", (field, ancestors) => {
+		const id = field.data?.id;
+		const datatypeId = field.data?.datatype;
+		const datatype = datatypeId === void 0 ? void 0 : ctx.datatypes.get(datatypeId);
+		if (id === void 0 || datatype === void 0 || isEmptyNode(field)) return SKIP;
+		const max = Math.max(1, ...datatype.componentsBySequence.keys());
+		for (const repetition of field.children) {
+			const count = repetition.children.length;
+			if (count > max) {
+				const message = file.message(messages.tooManyComponents(id, field.data?.name ?? "", count, max), {
+					ancestors: [
+						...ancestors,
+						field,
+						repetition
+					],
+					place: repetition.position ?? field.position
+				});
+				message.actual = String(count);
+			}
+		}
 		return SKIP;
 	});
 });
-/** Return the highest numeric key in a Map, or 0 if empty. */
-function maxKey(map) {
-	let max = 0;
-	for (const key of map.keys()) if (key > max) max = key;
-	return max;
-}
 //#endregion
 export { hl7v2LintExtraComponents as default };
 

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 { Field, Root, Segment } from \"@glion/ast\";\nimport { SKIP, visit } from \"@glion/util-visit\";\nimport { isEmptyNode } from \"@glion/utils\";\nimport { lintRule } from \"unified-lint-rule\";\n\n/**\n * Lint rule that warns when a field contains more components than its\n * datatype profile defines.\n *\n * For composite datatypes, checks against the defined component count.\n * For primitive datatypes, the maximum is 1 — any additional components\n * are flagged as extra.\n *\n * 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(hl7v2LintExtraComponents);\n *   ```;\n */\nconst hl7v2LintExtraComponents = lintRule<Root>(\n  { origin: \"hl7v2-lint:extra-components\" },\n  (tree, file) => {\n    const ctx = file.data.profile;\n    if (!ctx) {\n      return;\n    }\n\n    visit(tree, \"field\", (fieldNode, ancestors, info) => {\n      if (isEmptyNode(fieldNode as Field)) {\n        return SKIP;\n      }\n\n      const segment = ancestors.at(-1) as Segment | undefined;\n      if (!segment || segment.type !== \"segment\") {\n        return SKIP;\n      }\n\n      const fieldDef = ctx.fields.get(segment.name);\n      if (!fieldDef) {\n        return SKIP;\n      }\n\n      const fieldProfile = fieldDef.bySequence.get(info.sequence);\n      if (!fieldProfile) {\n        return SKIP;\n      }\n\n      const dtDef = ctx.datatypes.get(fieldProfile.datatype);\n      if (!dtDef) {\n        return SKIP;\n      }\n\n      // Primitives allow exactly 1 component (the value itself).\n      // Composites: the highest sequence key in the profile is the max\n      // component number (keys are 1-based HL7 sequence numbers).\n      const maxComponent =\n        dtDef.kind === \"primitive\" ? 1 : maxKey(dtDef.componentsBySequence);\n\n      if (maxComponent === 0) {\n        return SKIP;\n      }\n\n      for (const repetition of (fieldNode as Field).children) {\n        for (let i = maxComponent + 1; i <= repetition.children.length; i++) {\n          file.message(\n            `Component ${segment.name}-${info.sequence}.${i} is beyond the defined components for ${fieldProfile.datatype} (max: ${maxComponent} in v${ctx.version})`,\n            {\n              ancestors: [...ancestors, fieldNode, repetition],\n              place: repetition.position ?? fieldNode.position,\n            }\n          );\n        }\n      }\n\n      return SKIP;\n    });\n  }\n);\n\n/** Return the highest numeric key in a Map, or 0 if empty. */\nfunction maxKey(map: ReadonlyMap<number, unknown>): number {\n  let max = 0;\n  for (const key of map.keys()) {\n    if (key > max) {\n      max = key;\n    }\n  }\n  return max;\n}\n\nexport default hl7v2LintExtraComponents;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,2BAA2B,SAC/B,EAAE,QAAQ,+BAA+B,GACxC,MAAM,SAAS;CACd,MAAM,MAAM,KAAK,KAAK;AACtB,KAAI,CAAC,IACH;AAGF,OAAM,MAAM,UAAU,WAAW,WAAW,SAAS;AACnD,MAAI,YAAY,UAAmB,CACjC,QAAO;EAGT,MAAM,UAAU,UAAU,GAAG,GAAG;AAChC,MAAI,CAAC,WAAW,QAAQ,SAAS,UAC/B,QAAO;EAGT,MAAM,WAAW,IAAI,OAAO,IAAI,QAAQ,KAAK;AAC7C,MAAI,CAAC,SACH,QAAO;EAGT,MAAM,eAAe,SAAS,WAAW,IAAI,KAAK,SAAS;AAC3D,MAAI,CAAC,aACH,QAAO;EAGT,MAAM,QAAQ,IAAI,UAAU,IAAI,aAAa,SAAS;AACtD,MAAI,CAAC,MACH,QAAO;EAMT,MAAM,eACJ,MAAM,SAAS,cAAc,IAAI,OAAO,MAAM,qBAAqB;AAErE,MAAI,iBAAiB,EACnB,QAAO;AAGT,OAAK,MAAM,cAAe,UAAoB,SAC5C,MAAK,IAAI,IAAI,eAAe,GAAG,KAAK,WAAW,SAAS,QAAQ,IAC9D,MAAK,QACH,aAAa,QAAQ,KAAK,GAAG,KAAK,SAAS,GAAG,EAAE,wCAAwC,aAAa,SAAS,SAAS,aAAa,OAAO,IAAI,QAAQ,IACvJ;GACE,WAAW;IAAC,GAAG;IAAW;IAAW;IAAW;GAChD,OAAO,WAAW,YAAY,UAAU;GACzC,CACF;AAIL,SAAO;GACP;EAEL;;AAGD,SAAS,OAAO,KAA2C;CACzD,IAAI,MAAM;AACV,MAAK,MAAM,OAAO,IAAI,MAAM,CAC1B,KAAI,MAAM,IACR,OAAM;AAGV,QAAO"}
+{"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\";\n// 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 { isEmptyNode } from \"@glion/utils\";\nimport pluralize from \"pluralize\";\nimport { lintRule } from \"unified-lint-rule\";\n\nconst messages = {\n  tooManyComponents: (\n    field: string,\n    name: string,\n    count: number,\n    max: number\n  ) =>\n    `Field \\`${field}\\` (${name}) has ${pluralize(\"component\", count, true)}; it allows at most ${pluralize(\"component\", max, true)}.`,\n} as const;\n\n/**\n * Lint rule that reports a field repetition with more components than its\n * datatype defines.\n *\n * A primitive datatype defines one component. Empty fields are not checked.\n *\n * Reads `id` and `datatype` from `field.data`, so\n * `@glion/annotate-profile-fields` MUST run before it.\n *\n * @example\n *   ```typescript\n *   unified()\n *     .use(hl7v2AnnotateProfileContext)\n *     .use(hl7v2AnnotateProfileFields)\n *     .use(hl7v2LintExtraComponents);\n *   ```;\n */\nconst hl7v2LintExtraComponents = lintRule<Root>(\n  {\n    origin: \"hl7v2-lint:extra-components\",\n    url: \"https://github.com/rethinkhealth/glion/tree/main/packages/lint-profile-extra-components#readme\",\n  },\n  (tree, file) => {\n    const ctx = file.data.profile;\n    if (!ctx) {\n      return;\n    }\n\n    visit(tree, \"field\", (field, ancestors) => {\n      const id = field.data?.id;\n      const datatypeId = field.data?.datatype;\n      const datatype =\n        datatypeId === undefined ? undefined : ctx.datatypes.get(datatypeId);\n      if (id === undefined || datatype === undefined || isEmptyNode(field)) {\n        return SKIP;\n      }\n\n      // A primitive datatype has no component definitions; its value is\n      // component 1.\n      const max = Math.max(1, ...datatype.componentsBySequence.keys());\n\n      for (const repetition of field.children) {\n        const count = repetition.children.length;\n        if (count > max) {\n          const message = file.message(\n            messages.tooManyComponents(id, field.data?.name ?? \"\", count, max),\n            {\n              ancestors: [...ancestors, field, repetition],\n              place: repetition.position ?? field.position,\n            }\n          );\n          message.actual = String(count);\n        }\n      }\n      return SKIP;\n    });\n  }\n);\n\nexport default hl7v2LintExtraComponents;\n"],"mappings":";;;;;AAUA,MAAM,WAAW,EACf,oBACE,OACA,MACA,OACA,QAEA,WAAW,MAAM,MAAM,KAAK,QAAQ,UAAU,aAAa,OAAO,KAAK,CAAC,sBAAsB,UAAU,aAAa,KAAK,KAAK,CAAC,IACnI;;;;;;;;;;;;;;;;;;AAmBD,MAAM,2BAA2B,SAC/B;CACE,QAAQ;CACR,KAAK;CACN,GACA,MAAM,SAAS;CACd,MAAM,MAAM,KAAK,KAAK;AACtB,KAAI,CAAC,IACH;AAGF,OAAM,MAAM,UAAU,OAAO,cAAc;EACzC,MAAM,KAAK,MAAM,MAAM;EACvB,MAAM,aAAa,MAAM,MAAM;EAC/B,MAAM,WACJ,eAAe,KAAA,IAAY,KAAA,IAAY,IAAI,UAAU,IAAI,WAAW;AACtE,MAAI,OAAO,KAAA,KAAa,aAAa,KAAA,KAAa,YAAY,MAAM,CAClE,QAAO;EAKT,MAAM,MAAM,KAAK,IAAI,GAAG,GAAG,SAAS,qBAAqB,MAAM,CAAC;AAEhE,OAAK,MAAM,cAAc,MAAM,UAAU;GACvC,MAAM,QAAQ,WAAW,SAAS;AAClC,OAAI,QAAQ,KAAK;IACf,MAAM,UAAU,KAAK,QACnB,SAAS,kBAAkB,IAAI,MAAM,MAAM,QAAQ,IAAI,OAAO,IAAI,EAClE;KACE,WAAW;MAAC,GAAG;MAAW;MAAO;MAAW;KAC5C,OAAO,WAAW,YAAY,MAAM;KACrC,CACF;AACD,YAAQ,SAAS,OAAO,MAAM;;;AAGlC,SAAO;GACP;EAEL"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glion/lint-profile-extra-components",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Lint rule to warn when a composite field contains more components than its datatype profile defines",
   "keywords": [
     "health",
@@ -33,13 +33,16 @@
     "access": "public"
   },
   "dependencies": {
+    "pluralize": "8.0.0",
     "unified-lint-rule": "3.0.1",
-    "@glion/ast": "0.22.0",
-    "@glion/util-visit": "0.22.0",
-    "@glion/utils": "0.22.0"
+    "@glion/annotate-profile-fields": "0.24.0",
+    "@glion/ast": "0.24.0",
+    "@glion/util-visit": "0.24.0",
+    "@glion/utils": "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,11 @@
     "unified": "^11.0.5",
     "vfile": "^6.0.3",
     "vitest": "4.1.11",
-    "@glion/annotate-profile-context": "0.22.0",
-    "@glion/builder": "0.22.0",
+    "@glion/annotate-profile-context": "0.24.0",
+    "@glion/builder": "0.24.0",
+    "@glion/check-readme": "0.18.0",
     "@glion/testing": "0.18.0",
-    "@glion/tsconfig": "0.18.0",
-    "@glion/check-readme": "0.18.0"
+    "@glion/tsconfig": "0.18.0"
   },
   "engines": {
     "node": ">=22"