hl7v2 1.3.2 → 1.4.0

package/README.md

@@ -24,33 +24,18 @@ $ npm install hl7v2 --save
 HL7v2 is available under [MIT](LICENSE) license.
 
 [npm-image]: https://img.shields.io/npm/v/hl7v2.svg
-
 [npm-url]: https://npmjs.org/package/hl7v2
-
 [ci-test-image]: https://github.com/panates/hl7v2/actions/workflows/test.yml/badge.svg
-
 [ci-test-url]: https://github.com/panates/hl7v2/actions/workflows/test.yml
-
 [coveralls-image]: https://img.shields.io/coveralls/panates/hl7v2/master.svg
-
 [coveralls-url]: https://coveralls.io/r/panates/hl7v2
-
 [downloads-image]: https://img.shields.io/npm/dm/hl7v2.svg
-
 [downloads-url]: https://npmjs.org/package/hl7v2
-
 [gitter-image]: https://badges.gitter.im/panates/hl7v2.svg
-
 [gitter-url]: https://gitter.im/panates/hl7v2?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-
 [dependencies-image]: https://david-dm.org/panates/hl7v2/status.svg
-
-[dependencies-url]:https://david-dm.org/panates/hl7v2
-
+[dependencies-url]: https://david-dm.org/panates/hl7v2
 [devdependencies-image]: https://david-dm.org/panates/hl7v2/dev-status.svg
-
-[devdependencies-url]:https://david-dm.org/panates/hl7v2?type=dev
-
+[devdependencies-url]: https://david-dm.org/panates/hl7v2?type=dev
 [quality-image]: http://npm.packagequality.com/shield/hl7v2.png
-
 [quality-url]: http://packagequality.com/#?package=hl7v2

package/cjs/hl7-message-node.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7MessageNode = void 0;
+const hl7_segment_js_1 = require("./hl7-segment.js");
+class HL7MessageNode {
+    constructor(name) {
+        this.name = '';
+        this.items = [];
+        this.name = name;
+    }
+    /**
+     * Searches for a segment of a given type
+     */
+    getSegment(segmentType, index = 0) {
+        let k = 0;
+        for (const seg of this.items) {
+            if (seg instanceof hl7_segment_js_1.HL7Segment && seg.segmentType === segmentType) {
+                if (!index || index === k)
+                    return seg;
+                k++;
+            }
+        }
+    }
+    /**
+     * Searches for a segment of a given type in reverse order
+     */
+    getSegmentFromLast(segmentType, index = 0) {
+        for (let k = this.items.length - 1; k >= 0; k--) {
+            const seg = this.items[k];
+            if (seg instanceof hl7_segment_js_1.HL7Segment && seg.segmentType === segmentType) {
+                if (!index || index === k)
+                    return seg;
+                k++;
+            }
+        }
+    }
+}
+exports.HL7MessageNode = HL7MessageNode;

package/cjs/hl7-message.js

@@ -8,6 +8,7 @@ const iconv_lite_1 = tslib_1.__importDefault(require("iconv-lite"));
 const uid_1 = require("uid");
 const constants_js_1 = require("./constants.js");
 const hl7_error_js_1 = require("./hl7-error.js");
+const hl7_message_node_js_1 = require("./hl7-message-node.js");
 const hl7_segment_js_1 = require("./hl7-segment.js");
 class HL7Message {
     constructor(version = hl7v2_dictionary_1.HL7Version.v2_7_1, dictionaries) {
@@ -138,6 +139,79 @@ class HL7Message {
             }
         }
     }
+    buildStructureTree() {
+        // Get the message type to determine the structure
+        const messageType = this.messageType.replace('^', '_');
+        const messageDefinition = this.dictionary.messages?.[messageType];
+        if (!messageDefinition?.segments) {
+            const result = new hl7_message_node_js_1.HL7MessageNode('MESSAGE');
+            result.items.push(...this.segments);
+        }
+        // Helper function to process a segment definition recursively
+        const processSegmentDefinition = (segmentDef, nodeName, currentSegmentIndex) => {
+            const node = new hl7_message_node_js_1.HL7MessageNode(nodeName);
+            // Sort segment definitions by their index
+            const sortedEntries = Object.entries(segmentDef).sort(([, a], [, b]) => (a.idx || 0) - (b.idx || 0));
+            for (const [key, def] of sortedEntries) {
+                if (def.segments) {
+                    // This is a group - process recursively
+                    const maxOccurrences = def.max || Number.MAX_SAFE_INTEGER;
+                    let occurrenceCount = 0;
+                    const initialSegmentIndex = currentSegmentIndex.value;
+                    // Try to match segments for this group
+                    while (occurrenceCount < maxOccurrences &&
+                        currentSegmentIndex.value < this.segments.length) {
+                        const groupStartIndex = currentSegmentIndex.value;
+                        const groupNode = processSegmentDefinition(def.segments, key, currentSegmentIndex);
+                        // Check if we actually consumed any segments
+                        if (currentSegmentIndex.value > groupStartIndex &&
+                            groupNode.items.length > 0) {
+                            node.items.push(groupNode);
+                            occurrenceCount++;
+                        }
+                        else {
+                            // No segments matched, break the loop
+                            break;
+                        }
+                    }
+                    // If no occurrences found, reset to initial position
+                    if (occurrenceCount === 0) {
+                        currentSegmentIndex.value = initialSegmentIndex;
+                    }
+                }
+                else {
+                    // This is a leaf segment
+                    const maxOccurrences = def.max || Number.MAX_SAFE_INTEGER;
+                    const segmentType = key;
+                    // Match segments of this type
+                    let matchedCount = 0;
+                    while (matchedCount < maxOccurrences &&
+                        currentSegmentIndex.value < this.segments.length) {
+                        const currentSegment = this.segments[currentSegmentIndex.value];
+                        if (currentSegment.segmentType === segmentType) {
+                            node.items.push(currentSegment);
+                            currentSegmentIndex.value++;
+                            matchedCount++;
+                        }
+                        else {
+                            // Different segment type - stop matching
+                            break;
+                        }
+                    }
+                }
+            }
+            return node;
+        };
+        const segmentIndexRef = { value: 0 };
+        const result = processSegmentDefinition(messageDefinition.segments, messageType, segmentIndexRef);
+        // Add any remaining unmatched segments to the result
+        while (segmentIndexRef.value < this.segments.length) {
+            const segment = this.segments[segmentIndexRef.value];
+            result.items.push(segment);
+            segmentIndexRef.value++;
+        }
+        return result;
+    }
     createAck(ackCode = 'AA', textMessage) {
         const out = new HL7Message(this.version, this._dictionaries);
         const msh = out.header;

package/esm/hl7-message-node.js

@@ -0,0 +1,34 @@
+import { HL7Segment } from './hl7-segment.js';
+export class HL7MessageNode {
+    constructor(name) {
+        this.name = '';
+        this.items = [];
+        this.name = name;
+    }
+    /**
+     * Searches for a segment of a given type
+     */
+    getSegment(segmentType, index = 0) {
+        let k = 0;
+        for (const seg of this.items) {
+            if (seg instanceof HL7Segment && seg.segmentType === segmentType) {
+                if (!index || index === k)
+                    return seg;
+                k++;
+            }
+        }
+    }
+    /**
+     * Searches for a segment of a given type in reverse order
+     */
+    getSegmentFromLast(segmentType, index = 0) {
+        for (let k = this.items.length - 1; k >= 0; k--) {
+            const seg = this.items[k];
+            if (seg instanceof HL7Segment && seg.segmentType === segmentType) {
+                if (!index || index === k)
+                    return seg;
+                k++;
+            }
+        }
+    }
+}

package/esm/hl7-message.js

@@ -4,6 +4,7 @@ import iconv from 'iconv-lite';
 import { uid } from 'uid';
 import { COMPONENT_SEPARATOR, CR, ESCAPE_CHARACTER, FIELD_SEPARATOR, FS, LF, REPETITION_SEPARATOR, SUBCOMPONENT_SEPARATOR, VT, } from './constants.js';
 import { HL7Error } from './hl7-error.js';
+import { HL7MessageNode } from './hl7-message-node.js';
 import { HL7Segment, } from './hl7-segment.js';
 export class HL7Message {
     constructor(version = HL7Version.v2_7_1, dictionaries) {
@@ -134,6 +135,79 @@ export class HL7Message {
             }
         }
     }
+    buildStructureTree() {
+        // Get the message type to determine the structure
+        const messageType = this.messageType.replace('^', '_');
+        const messageDefinition = this.dictionary.messages?.[messageType];
+        if (!messageDefinition?.segments) {
+            const result = new HL7MessageNode('MESSAGE');
+            result.items.push(...this.segments);
+        }
+        // Helper function to process a segment definition recursively
+        const processSegmentDefinition = (segmentDef, nodeName, currentSegmentIndex) => {
+            const node = new HL7MessageNode(nodeName);
+            // Sort segment definitions by their index
+            const sortedEntries = Object.entries(segmentDef).sort(([, a], [, b]) => (a.idx || 0) - (b.idx || 0));
+            for (const [key, def] of sortedEntries) {
+                if (def.segments) {
+                    // This is a group - process recursively
+                    const maxOccurrences = def.max || Number.MAX_SAFE_INTEGER;
+                    let occurrenceCount = 0;
+                    const initialSegmentIndex = currentSegmentIndex.value;
+                    // Try to match segments for this group
+                    while (occurrenceCount < maxOccurrences &&
+                        currentSegmentIndex.value < this.segments.length) {
+                        const groupStartIndex = currentSegmentIndex.value;
+                        const groupNode = processSegmentDefinition(def.segments, key, currentSegmentIndex);
+                        // Check if we actually consumed any segments
+                        if (currentSegmentIndex.value > groupStartIndex &&
+                            groupNode.items.length > 0) {
+                            node.items.push(groupNode);
+                            occurrenceCount++;
+                        }
+                        else {
+                            // No segments matched, break the loop
+                            break;
+                        }
+                    }
+                    // If no occurrences found, reset to initial position
+                    if (occurrenceCount === 0) {
+                        currentSegmentIndex.value = initialSegmentIndex;
+                    }
+                }
+                else {
+                    // This is a leaf segment
+                    const maxOccurrences = def.max || Number.MAX_SAFE_INTEGER;
+                    const segmentType = key;
+                    // Match segments of this type
+                    let matchedCount = 0;
+                    while (matchedCount < maxOccurrences &&
+                        currentSegmentIndex.value < this.segments.length) {
+                        const currentSegment = this.segments[currentSegmentIndex.value];
+                        if (currentSegment.segmentType === segmentType) {
+                            node.items.push(currentSegment);
+                            currentSegmentIndex.value++;
+                            matchedCount++;
+                        }
+                        else {
+                            // Different segment type - stop matching
+                            break;
+                        }
+                    }
+                }
+            }
+            return node;
+        };
+        const segmentIndexRef = { value: 0 };
+        const result = processSegmentDefinition(messageDefinition.segments, messageType, segmentIndexRef);
+        // Add any remaining unmatched segments to the result
+        while (segmentIndexRef.value < this.segments.length) {
+            const segment = this.segments[segmentIndexRef.value];
+            result.items.push(segment);
+            segmentIndexRef.value++;
+        }
+        return result;
+    }
     createAck(ackCode = 'AA', textMessage) {
         const out = new HL7Message(this.version, this._dictionaries);
         const msh = out.header;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hl7v2",
   "description": "HL7 v2 parser, serializer, validator for NodeJS",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
@@ -15,7 +15,7 @@
     "uid": "^2.0.2"
   },
   "peerDependencies": {
-    "hl7v2-dictionary": "^1.3.2"
+    "hl7v2-dictionary": "^1.4.0"
   },
   "type": "module",
   "exports": {

package/types/hl7-message-node.d.ts

@@ -0,0 +1,14 @@
+import { HL7Segment } from './hl7-segment.js';
+export declare class HL7MessageNode {
+    name: string;
+    items: (HL7Segment | HL7MessageNode)[];
+    constructor(name: string);
+    /**
+     * Searches for a segment of a given type
+     */
+    getSegment(segmentType: string, index?: number): HL7Segment | undefined;
+    /**
+     * Searches for a segment of a given type in reverse order
+     */
+    getSegmentFromLast(segmentType: string, index?: number): HL7Segment | undefined;
+}

package/types/hl7-message.d.ts

@@ -1,4 +1,5 @@
 import { AcknowledgmentCode, HL7Dictionary, HL7Version } from 'hl7v2-dictionary';
+import { HL7MessageNode } from './hl7-message-node.js';
 import { HL7Segment, Hl7SegmentParseOptions, Hl7SegmentSerializeOptions } from './hl7-segment.js';
 export declare class HL7Message {
     private readonly _dictionaries;
@@ -29,6 +30,7 @@ export declare class HL7Message {
     getSegmentFromLast(segmentType: string, index?: number): HL7Segment | undefined;
     toHL7String(options?: HL7MessageSerializeOptions): string;
     parse(input: string | Buffer, options?: HL7MessageParseOptions): void;
+    buildStructureTree(): HL7MessageNode;
     createAck(ackCode?: AcknowledgmentCode, textMessage?: string): HL7Message;
     createNak(errors: (Error | string)[]): HL7Message;
     addError(error: Error | string): void;