@pritiranjan/hl7v2 0.1.0

package/dist/segments/index.cjs

@@ -0,0 +1,636 @@
+'use strict';
+
+// src/escape.ts
+function escRx(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function decodeEscapes(value, enc) {
+  const esc = enc.escape;
+  if (!value.includes(esc)) return value;
+  const pattern = new RegExp(`${escRx(esc)}([^${escRx(esc)}]*)${escRx(esc)}`, "g");
+  return value.replace(pattern, (match, seq) => {
+    switch (seq) {
+      case "F":
+        return enc.field;
+      case "S":
+        return enc.component;
+      case "T":
+        return enc.subComponent;
+      case "R":
+        return enc.repetition;
+      case "E":
+        return enc.escape;
+      case "H":
+        return "\x1B[1m";
+      case "N":
+        return "\x1B[0m";
+      case ".br":
+        return "\n";
+      default: {
+        if (seq.startsWith("X") && seq.length > 1) {
+          try {
+            const hex = seq.slice(1);
+            const bytes = new Uint8Array(hex.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? []);
+            return new TextDecoder().decode(bytes);
+          } catch {
+            return match;
+          }
+        }
+        return match;
+      }
+    }
+  });
+}
+
+// src/errors.ts
+var HL7ParseError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "HL7ParseError";
+    this.line = options?.line;
+    this.segmentId = options?.segmentId;
+    if (options?.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+};
+
+// src/datetime.ts
+function parseHL7DateTime(raw) {
+  const s = raw.trim();
+  if (!s) return void 0;
+  if (s.length < 4) {
+    throw new HL7ParseError(`Cannot parse HL7 date/time: "${s}" \u2014 minimum format is YYYY`);
+  }
+  let base = s;
+  let offsetMin = 0;
+  const tzMatch = /([+-])(\d{2})(\d{2})$/.exec(s);
+  if (tzMatch) {
+    const sign = tzMatch[1] === "+" ? 1 : -1;
+    const tzHours = parseInt(tzMatch[2] ?? "0", 10);
+    const tzMins = parseInt(tzMatch[3] ?? "0", 10);
+    offsetMin = sign * (tzHours * 60 + tzMins);
+    base = s.slice(0, s.length - 5);
+  }
+  let fracMs = 0;
+  const dotIdx = base.indexOf(".");
+  if (dotIdx !== -1) {
+    const fracStr = base.slice(dotIdx);
+    fracMs = Math.round(parseFloat(fracStr) * 1e3);
+    base = base.slice(0, dotIdx);
+  }
+  const year = parseInt(base.slice(0, 4), 10);
+  const month = parseInt(base.slice(4, 6) || "01", 10) - 1;
+  const day = parseInt(base.slice(6, 8) || "01", 10);
+  const hour = parseInt(base.slice(8, 10) || "00", 10);
+  const min = parseInt(base.slice(10, 12) || "00", 10);
+  const sec = parseInt(base.slice(12, 14) || "00", 10);
+  if (isNaN(year) || isNaN(month) || isNaN(day)) {
+    throw new HL7ParseError(`Cannot parse HL7 date/time: "${s}"`);
+  }
+  const utcMs = Date.UTC(year, month, day, hour, min, sec, fracMs) - offsetMin * 6e4;
+  const result = new Date(utcMs);
+  if (isNaN(result.getTime())) {
+    throw new HL7ParseError(`Cannot parse HL7 date/time: "${s}"`);
+  }
+  return result;
+}
+
+// src/segments/base.ts
+var TypedSegment = class {
+  constructor(seg, enc) {
+    this.seg = seg;
+    this.enc = enc;
+  }
+  /** The raw underlying {@link HL7Segment}. */
+  get raw() {
+    return this.seg;
+  }
+  /** Return the raw field structure at the given 1-based field number. */
+  field(num) {
+    return this.seg.fields[num - 1];
+  }
+  /**
+   * Extract a scalar string value from the segment.
+   * All arguments are 1-based. Missing elements return `''`.
+   * Escape sequences are decoded automatically.
+   */
+  str(fieldNum, component = 1, subComponent = 1, repetition = 1) {
+    const f = this.field(fieldNum);
+    if (!f) return "";
+    const raw = f[repetition - 1]?.[component - 1]?.[subComponent - 1] ?? "";
+    return decodeEscapes(raw, this.enc);
+  }
+  /**
+   * Extract a string value from the segment without escape decoding.
+   * Useful when you need to preserve the raw HL7 encoding.
+   */
+  rawStr(fieldNum, component = 1, subComponent = 1, repetition = 1) {
+    const f = this.field(fieldNum);
+    if (!f) return "";
+    return f[repetition - 1]?.[component - 1]?.[subComponent - 1] ?? "";
+  }
+  /** Extract a Date from an HL7 date/time field. Returns `undefined` if empty. */
+  date(fieldNum, component = 1) {
+    const raw = this.rawStr(fieldNum, component);
+    if (!raw) return void 0;
+    try {
+      return parseHL7DateTime(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Extract a numeric value from a field. Returns `undefined` if empty or non-numeric. */
+  num(fieldNum, component = 1) {
+    const raw = this.str(fieldNum, component);
+    if (!raw) return void 0;
+    const n = parseFloat(raw);
+    return isNaN(n) ? void 0 : n;
+  }
+  /** Return all repetitions of a field as an array of first-component strings. */
+  repetitions(fieldNum, component = 1) {
+    const f = this.field(fieldNum);
+    if (!f) return [];
+    return f.map((rep) => {
+      const raw = rep[component - 1]?.[0] ?? "";
+      return decodeEscapes(raw, this.enc);
+    }).filter((v) => v !== "");
+  }
+};
+
+// src/segments/msh.ts
+var MSH = class extends TypedSegment {
+  constructor(seg, enc) {
+    super(seg, enc);
+  }
+  /** MSH.3 — Sending Application */
+  sendingApplication() {
+    return this.str(3);
+  }
+  /** MSH.4 — Sending Facility */
+  sendingFacility() {
+    return this.str(4);
+  }
+  /** MSH.5 — Receiving Application */
+  receivingApplication() {
+    return this.str(5);
+  }
+  /** MSH.6 — Receiving Facility */
+  receivingFacility() {
+    return this.str(6);
+  }
+  /** MSH.7 — Date/Time of Message */
+  dateTimeOfMessage() {
+    return this.date(7);
+  }
+  /** MSH.9 — Message Type (e.g., `{ type: 'ADT', event: 'A01', structure: 'ADT_A01' }`). */
+  messageType() {
+    const field = this.field(9);
+    const firstRep = field?.[0] ?? [];
+    const struct = firstRep[2]?.[0];
+    return {
+      type: firstRep[0]?.[0] ?? "",
+      event: firstRep[1]?.[0] ?? "",
+      structure: struct !== void 0 && struct !== "" ? struct : void 0
+    };
+  }
+  /** MSH.10 — Message Control ID (used for ACK correlation). */
+  messageControlId() {
+    return this.str(10);
+  }
+  /**
+   * MSH.11 — Processing ID.
+   * `'P'` = Production, `'D'` = Debugging, `'T'` = Training.
+   */
+  processingId() {
+    return this.str(11);
+  }
+  /** MSH.12 — HL7 version (e.g., `'2.5.1'`). */
+  version() {
+    return this.str(12);
+  }
+  /** MSH.15 — Accept Acknowledgement Type. */
+  acceptAcknowledgementType() {
+    return this.str(15);
+  }
+  /** MSH.16 — Application Acknowledgement Type. */
+  applicationAcknowledgementType() {
+    return this.str(16);
+  }
+  /** MSH.17 — Country Code (ISO 3166). */
+  countryCode() {
+    return this.str(17);
+  }
+};
+
+// src/segments/pid.ts
+var PID = class extends TypedSegment {
+  constructor(seg, enc) {
+    super(seg, enc);
+  }
+  /** PID.1 — Set ID (1-based sequence number within the message). */
+  setId() {
+    return this.num(1);
+  }
+  /**
+   * PID.3 — Patient Identifier List.
+   *
+   * Returns all patient identifiers (MRN, SSN, national ID, etc.).
+   * Each identifier has its own type code and assigning authority.
+   *
+   * @example
+   * pid.patientIdentifiers()
+   * // [{ id: 'MRN123', assigningAuthority: 'HOSPITAL', identifierTypeCode: 'MR' }]
+   */
+  patientIdentifiers() {
+    const field = this.field(3);
+    if (!field) return [];
+    return field.map((rep) => ({
+      id: rep[0]?.[0] ?? "",
+      checkDigit: rep[1]?.[0] ?? "",
+      assigningAuthority: rep[3]?.[0] ?? "",
+      identifierTypeCode: rep[4]?.[0] ?? ""
+    }));
+  }
+  /**
+   * PID.3 — Primary patient identifier (first in the list).
+   * Returns the raw identifier string (e.g., `'MRN123'`).
+   */
+  patientId() {
+    return this.str(3, 1);
+  }
+  /**
+   * PID.5 — Patient Name (first/primary name).
+   *
+   * Patient names follow the XPN (Extended Person Name) data type.
+   * Components: family ^ given ^ middle ^ suffix ^ prefix ^ degree
+   */
+  patientName() {
+    return {
+      family: this.str(5, 1),
+      given: this.str(5, 2),
+      middle: this.str(5, 3),
+      suffix: this.str(5, 4),
+      prefix: this.str(5, 5),
+      degree: this.str(5, 6)
+    };
+  }
+  /**
+   * PID.5 — All patient names (legal, alias, display, etc.).
+   * Most messages contain a single name; some include aliases or prior names.
+   */
+  allPatientNames() {
+    const field = this.field(5);
+    if (!field) return [];
+    return field.map((rep) => ({
+      family: rep[0]?.[0] ?? "",
+      given: rep[1]?.[0] ?? "",
+      middle: rep[2]?.[0] ?? "",
+      suffix: rep[3]?.[0] ?? "",
+      prefix: rep[4]?.[0] ?? "",
+      degree: rep[5]?.[0] ?? ""
+    }));
+  }
+  /**
+   * PID.7 — Date/Time of Birth.
+   * Returns `undefined` if absent or unparseable.
+   */
+  dateOfBirth() {
+    return this.date(7);
+  }
+  /**
+   * PID.8 — Administrative Sex (HL7 table 0001).
+   * `'M'` Male · `'F'` Female · `'O'` Other · `'U'` Unknown
+   * `'A'` Ambiguous · `'N'` Not applicable · `'C'` Complex
+   */
+  sex() {
+    return this.str(8);
+  }
+  /**
+   * PID.10 — Race (HL7 table 0005, CWE data type).
+   * Returns the race code (first component).
+   */
+  race() {
+    return this.str(10, 1);
+  }
+  /**
+   * PID.11 — Patient Address (first address).
+   * Addresses follow the XAD (Extended Address) data type.
+   */
+  address() {
+    return {
+      streetAddress: this.str(11, 1),
+      otherDesignation: this.str(11, 2),
+      city: this.str(11, 3),
+      state: this.str(11, 4),
+      postalCode: this.str(11, 5),
+      country: this.str(11, 6),
+      addressType: this.str(11, 7)
+    };
+  }
+  /** PID.13 — Phone Number - Home (first number, XTN data type). */
+  homePhone() {
+    return this.str(13, 1);
+  }
+  /** PID.14 — Phone Number - Business (first number, XTN data type). */
+  workPhone() {
+    return this.str(14, 1);
+  }
+  /**
+   * PID.15 — Primary Language (CE data type).
+   * Returns the language code (e.g., `'ENG'`, `'SPA'`).
+   */
+  primaryLanguage() {
+    return this.str(15, 1);
+  }
+  /** PID.16 — Marital Status (HL7 table 0002). */
+  maritalStatus() {
+    return this.str(16, 1);
+  }
+  /** PID.17 — Religion (HL7 table 0006). */
+  religion() {
+    return this.str(17, 1);
+  }
+  /**
+   * PID.18 — Patient Account Number.
+   * The billing/visit account number (distinct from the medical record number).
+   */
+  accountNumber() {
+    return this.str(18, 1);
+  }
+  /** PID.19 — SSN Number - Patient (US Social Security Number). */
+  ssn() {
+    return this.str(19);
+  }
+  /** PID.22 — Ethnic Group (HL7 table 0189, CWE data type). */
+  ethnicGroup() {
+    return this.str(22, 1);
+  }
+  /** PID.29 — Patient Death Date and Time. `undefined` if patient is not deceased. */
+  deathDateTime() {
+    return this.date(29);
+  }
+  /**
+   * PID.30 — Patient Death Indicator.
+   * `'Y'` = deceased, `'N'` = not deceased.
+   */
+  deathIndicator() {
+    return this.str(30);
+  }
+};
+
+// src/segments/obx.ts
+var OBX = class extends TypedSegment {
+  constructor(seg, enc) {
+    super(seg, enc);
+  }
+  /** OBX.1 — Set ID (sequence number within the message, 1-based). */
+  setId() {
+    return this.num(1);
+  }
+  /**
+   * OBX.2 — Value Type.
+   * Indicates the data type of the observation value in OBX.5.
+   * Common values: `'NM'` (numeric), `'ST'` (string), `'CWE'` (coded).
+   */
+  valueType() {
+    return this.str(2);
+  }
+  /**
+   * OBX.3 — Observation Identifier.
+   * Typically a LOINC code identifying what was measured.
+   *
+   * @example
+   * obx.observationIdentifier()
+   * // { code: '718-7', description: 'Hemoglobin [Mass/volume] in Blood', codingSystem: 'LN' }
+   */
+  observationIdentifier() {
+    return {
+      code: this.str(3, 1),
+      description: this.str(3, 2),
+      codingSystem: this.str(3, 3)
+    };
+  }
+  /** OBX.4 — Observation Sub-ID (groups related OBX segments). */
+  observationSubId() {
+    return this.str(4);
+  }
+  /**
+   * OBX.5 — Observation Value (raw string).
+   *
+   * The interpretation depends on OBX.2 (value type).
+   * Use {@link numericValue} for `NM`, {@link codedValue} for `CWE`/`CE`.
+   */
+  observationValue() {
+    return this.str(5);
+  }
+  /**
+   * OBX.5 — Observation value interpreted as a number.
+   * Returns `undefined` if the value type is not `NM` or the value is absent.
+   *
+   * For structured numerics (SN type like `'>10.5'`), use {@link observationValue}.
+   */
+  numericValue() {
+    if (this.str(2) !== "NM") return void 0;
+    return this.num(5);
+  }
+  /**
+   * OBX.5 — Observation value as a coded element (CWE/CE value type).
+   * Returns `{ code, description, codingSystem }`.
+   */
+  codedValue() {
+    return {
+      code: this.str(5, 1),
+      description: this.str(5, 2),
+      codingSystem: this.str(5, 3)
+    };
+  }
+  /**
+   * OBX.6 — Units (CWE data type).
+   * Returns the unit code (e.g., `'g/dL'`, `'10*3/uL'`, `'mmHg'`).
+   */
+  units() {
+    return this.str(6, 1);
+  }
+  /**
+   * OBX.7 — References Range.
+   * The normal range as a string (e.g., `'3.5-5.0'`, `'<200'`).
+   */
+  referenceRange() {
+    return this.str(7);
+  }
+  /**
+   * OBX.8 — Interpretation Codes (formerly Abnormal Flags).
+   * Returns all flags for this result (a field can have multiple repetitions).
+   *
+   * Common values: `'H'` high, `'L'` low, `'HH'` critical high, `'LL'` critical low,
+   * `'N'` normal, `'A'` abnormal, `'POS'` positive, `'NEG'` negative.
+   */
+  abnormalFlags() {
+    return this.repetitions(8);
+  }
+  /**
+   * OBX.8 — Primary interpretation code (first flag).
+   * Returns `''` if the result has no flags (i.e., it is normal / in-range).
+   */
+  primaryAbnormalFlag() {
+    return this.str(8);
+  }
+  /** OBX.11 — Observation Result Status (HL7 table 0085). */
+  resultStatus() {
+    return this.str(11);
+  }
+  /** OBX.14 — Date/Time of Observation. */
+  observationDateTime() {
+    return this.date(14);
+  }
+  /** OBX.15 — Producer's ID (the lab or device that produced the result). */
+  producerId() {
+    return this.str(15, 1);
+  }
+  /** OBX.16 — Responsible Observer (clinician who verified the result). */
+  responsibleObserver() {
+    return this.str(16, 1);
+  }
+  /** OBX.19 — Date/Time of Analysis. */
+  analysisDateTime() {
+    return this.date(19);
+  }
+  /**
+   * Convenience: return `true` if this result has a critical abnormal flag
+   * (`'HH'` or `'LL'`).
+   */
+  isCritical() {
+    const flags = this.abnormalFlags();
+    return flags.includes("HH") || flags.includes("LL");
+  }
+  /**
+   * Convenience: return `true` if the result is finalised (`resultStatus() === 'F'`).
+   */
+  isFinal() {
+    return this.str(11) === "F";
+  }
+};
+
+// src/segments/pv1.ts
+var PV1 = class extends TypedSegment {
+  constructor(seg, enc) {
+    super(seg, enc);
+  }
+  /** PV1.1 — Set ID. */
+  setId() {
+    return this.num(1);
+  }
+  /**
+   * PV1.2 — Patient Class (HL7 table 0004).
+   * `'I'` Inpatient · `'O'` Outpatient · `'E'` Emergency · `'P'` Preadmit
+   */
+  patientClass() {
+    return this.str(2);
+  }
+  /**
+   * PV1.3 — Assigned Patient Location.
+   * The bed the patient is currently assigned to.
+   */
+  assignedLocation() {
+    return {
+      pointOfCare: this.str(3, 1),
+      room: this.str(3, 2),
+      bed: this.str(3, 3),
+      facility: this.str(3, 4),
+      buildingCode: this.str(3, 7),
+      floor: this.str(3, 8)
+    };
+  }
+  /** PV1.4 — Admission Type (e.g., `'A'` = accident, `'E'` = emergency). */
+  admissionType() {
+    return this.str(4);
+  }
+  /**
+   * PV1.7 — Attending Doctor.
+   * The physician primarily responsible for the patient's care.
+   */
+  attendingDoctor() {
+    return {
+      id: this.str(7, 1),
+      family: this.str(7, 2),
+      given: this.str(7, 3),
+      middle: this.str(7, 4),
+      credential: this.str(7, 7)
+    };
+  }
+  /**
+   * PV1.8 — Referring Doctor.
+   * The physician who referred the patient.
+   */
+  referringDoctor() {
+    return {
+      id: this.str(8, 1),
+      family: this.str(8, 2),
+      given: this.str(8, 3),
+      middle: this.str(8, 4),
+      credential: this.str(8, 7)
+    };
+  }
+  /**
+   * PV1.9 — Consulting Doctor.
+   * Returns all consulting doctors (field can repeat).
+   */
+  consultingDoctors() {
+    const field = this.field(9);
+    if (!field) return [];
+    return field.map((rep) => ({
+      id: rep[0]?.[0] ?? "",
+      family: rep[1]?.[0] ?? "",
+      given: rep[2]?.[0] ?? "",
+      middle: rep[3]?.[0] ?? "",
+      credential: rep[7]?.[0] ?? ""
+    }));
+  }
+  /** PV1.10 — Hospital Service (e.g., `'MED'`, `'SUR'`, `'CAR'`). */
+  hospitalService() {
+    return this.str(10);
+  }
+  /** PV1.14 — Admit Source (HL7 table 0023). */
+  admitSource() {
+    return this.str(14);
+  }
+  /** PV1.18 — Patient Type. */
+  patientType() {
+    return this.str(18);
+  }
+  /** PV1.19 — Visit Number (account number for this specific visit). */
+  visitNumber() {
+    return this.str(19, 1);
+  }
+  /** PV1.36 — Discharge Disposition (HL7 table 0112). */
+  dischargeDisposition() {
+    return this.str(36);
+  }
+  /**
+   * PV1.44 — Admit Date/Time.
+   * When the patient was admitted to this care setting.
+   */
+  admitDateTime() {
+    return this.date(44);
+  }
+  /**
+   * PV1.45 — Discharge Date/Time.
+   * `undefined` if the patient has not yet been discharged.
+   */
+  dischargeDateTime() {
+    return this.date(45);
+  }
+};
+
+exports.MSH = MSH;
+exports.OBX = OBX;
+exports.PID = PID;
+exports.PV1 = PV1;
+exports.TypedSegment = TypedSegment;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map