@molgenis/vip-report-template 6.1.1 → 7.0.0

package/src/utils/{sortUtils.ts → query/sort.ts}

@@ -1,6 +1,9 @@
-import { FieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
-import { Metadata } from "@molgenis/vip-report-vcf/src/Vcf";
-import { CompareFn, SortOrder, SortPath } from "@molgenis/vip-report-api/src/Api";
+import { FieldMetadata, VcfMetadata } from "@molgenis/vip-report-vcf";
+import { CompareFn, SortOrder, SortPath } from "@molgenis/vip-report-api";
+import { ConfigSort, ConfigSortOrder } from "../../types/configSort";
+
+import { createInfoSortPath } from "./selector.ts";
+import { InvalidSortPathError } from "../error.ts";
 
 export type Direction = "asc" | "desc";
 
@@ -16,25 +19,42 @@ export type Sort = {
 export const DIRECTION_ASCENDING = "asc" as Direction;
 export const DIRECTION_DESCENDING = "desc" as Direction;
 
-class InvalidSortPathError extends Error {
-  constructor(path: SortPath) {
-    super(`invalid record sort path '[${path.join(",")}]'`);
-    this.name = "InvalidSortPathError";
+/**
+ * @param storeSort null=do not sort, undefined=sort behavior is undefined, fall back to default sort
+ * @param configSort default sort
+ */
+export function createSort(
+  storeSort: SortOrder | SortOrder[] | null | undefined,
+  configSort: ConfigSort | undefined,
+): SortOrder | SortOrder[] {
+  if (storeSort !== undefined) {
+    return storeSort || [];
+  } else {
+    const sortOrders = configSort != undefined ? configSort.orders.map((order) => mapOrder(order)) : undefined;
+    return sortOrders !== undefined ? sortOrders : [];
   }
 }
-export function createRecordSort(recordsMeta: Metadata, sort?: SortOrder | SortOrder[]): Sort {
+
+export function mapOrder(sort: ConfigSortOrder): SortOrder {
+  return {
+    property: createInfoSortPath(sort.field),
+    compare: createDirection(sort.direction),
+  };
+}
+
+export function createRecordSort(recordsMeta: VcfMetadata, sort?: SortOrder | SortOrder[]): Sort {
   const orders = sort ? (Array.isArray(sort) ? sort : [sort]) : [];
   return { orders: orders.map((order) => createOrder(order, recordsMeta)) };
 }
 
-function createOrder(sort: SortOrder, recordsMeta: Metadata): Order {
+function createOrder(sort: SortOrder, recordsMeta: VcfMetadata): Order {
   return {
     field: createField(sort.property, recordsMeta),
     direction: createDirection(sort.compare),
   };
 }
 
-function createField(property: string | SortPath, recordsMeta: Metadata): FieldMetadata {
+function createField(property: string | SortPath, recordsMeta: VcfMetadata): FieldMetadata {
   const path = Array.isArray(property) ? property : [property];
   if (path.length < 2 || path.length > 3 || path[0] !== "n" || typeof path[1] !== "string") {
     throw new Error(`invalid record sort path '[${path.join(",")}]'`);
@@ -52,6 +72,7 @@ function createField(property: string | SortPath, recordsMeta: Metadata): FieldM
     if (field.nested === undefined) throw new InvalidSortPathError(path);
 
     field = field.nested.items[pathIndex];
+    if (field === undefined) throw new InvalidSortPathError(path);
   }
   return field;
 }
@@ -60,6 +81,6 @@ function createDirection(compare?: "asc" | "desc" | CompareFn): Direction {
   if (compare === undefined) return DIRECTION_ASCENDING;
   else if (compare === DIRECTION_ASCENDING) return DIRECTION_ASCENDING;
   else if (compare === DIRECTION_DESCENDING) return DIRECTION_DESCENDING;
-  else if (typeof compare === "function") throw new Error("cannot convert sort with custom compare function");
+  else if (typeof compare === "function") throw new Error("cannot convert sort with composed compare function");
   else throw new Error(`invalid sort compare '${compare}'`);
 }

package/src/utils/sample.ts

@@ -1,11 +1,12 @@
-import { Sample } from "@molgenis/vip-report-api/src/Api";
+import { Item, Sample } from "@molgenis/vip-report-api";
+import { SampleContainer } from "./api.ts";
 
-export function getSampleLabel(sample: Sample) {
-  return sample.person.individualId;
+export function getSampleLabel(sample: Item<Sample>) {
+  return sample.data.person.individualId;
 }
 
-export function getSampleSexLabel(sample: Sample): string {
-  switch (sample.person.sex) {
+export function getSampleSexLabel(sample: Item<Sample>): string {
+  switch (sample.data.person.sex) {
     case "FEMALE":
       return "female";
     case "MALE":
@@ -15,8 +16,8 @@ export function getSampleSexLabel(sample: Sample): string {
   }
 }
 
-export function getSampleAffectedStatusLabel(sample: Sample): string {
-  switch (sample.person.affectedStatus) {
+export function getSampleAffectedStatusLabel(sample: Item<Sample>): string {
+  switch (sample.data.person.affectedStatus) {
     case "AFFECTED":
       return "affected";
     case "UNAFFECTED":
@@ -30,36 +31,19 @@ function isFamily(sample: Sample, samples: Sample): boolean {
   return sample.person.familyId === samples.person.familyId;
 }
 
-function isSampleMother(sample: Sample, samples: Sample): boolean {
-  return isFamily(sample, samples) && samples.person.individualId === sample.person.maternalId;
+export function isSampleMother(sample: Sample, sampleMaternal: Sample): boolean {
+  return isFamily(sample, sampleMaternal) && sampleMaternal.person.individualId === sample.person.maternalId;
 }
 
-export function getSampleMother(sample: Sample, samples: Sample[]): Sample | undefined {
-  if (sample.person.maternalId !== "0") {
-    for (const otherSample of samples) {
-      if (isSampleMother(sample, otherSample)) return otherSample;
-    }
-  }
-}
-
-function isSampleFather(sample: Sample, samples: Sample): boolean {
-  return isFamily(sample, samples) && samples.person.individualId === sample.person.paternalId;
+export function isSampleFather(sample: Sample, samplePaternal: Sample): boolean {
+  return isFamily(sample, samplePaternal) && samplePaternal.person.individualId === sample.person.paternalId;
 }
 
-export function getSampleFather(sample: Sample, samples: Sample[]): Sample | undefined {
-  if (sample.person.paternalId !== "0") {
-    for (const otherSample of samples) {
-      if (isSampleFather(sample, otherSample)) return otherSample;
-    }
-  }
-}
-
-export function getSampleFamilyMembersWithoutParents(sample: Sample, samples: Sample[]): Sample[] {
-  const familyMembersWithoutParents: Sample[] = [];
-  for (const otherSample of samples) {
-    if (isFamily(sample, otherSample) && !isSampleFather(sample, otherSample) && !isSampleMother(sample, otherSample)) {
-      if (sample.person.individualId !== otherSample.person.individualId) familyMembersWithoutParents.push(otherSample);
-    }
-  }
-  return familyMembersWithoutParents;
+/**
+ * Returns all samples for the given sample pedigree including the given sample itself
+ */
+export function getPedigreeSamples(sample: SampleContainer): Item<Sample>[] {
+  return [sample.item, sample.maternalSample, sample.paternalSample, ...sample.otherPedigreeSamples].filter(
+    (sample) => sample !== null,
+  );
 }

package/src/utils/utils.ts

@@ -1,3 +1,67 @@
-export function arrayEquals<T>(a: T[], b: T[]) {
-  return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((val, index) => val === b[index]);
+import { Item } from "@molgenis/vip-report-api";
+import { VcfRecord } from "@molgenis/vip-report-vcf";
+import { InvalidIdException } from "./error.ts";
+
+export function getRecordLabel(item: Item<VcfRecord>) {
+  const record = item.data;
+  const refLabel = getAlleleLabel(record.r);
+  return `${record.c}:${record.p} ${record.a.map((a) => `${refLabel}>${getAlleleLabel(a)}`).join(" / ")}`;
+}
+
+function getAlleleLabel(allele: string | null) {
+  return allele !== null
+    ? allele.length > 4
+      ? allele.substring(0, 2) + "\u2026" + allele.charAt(allele.length - 1)
+      : allele
+    : ".";
+}
+
+/**
+ * Create an absolute url path from a list of components
+ */
+export function href(urlComponents: (string | number)[]) {
+  return "/" + urlComponents.map((urlComponent) => encodeURIComponent(urlComponent)).join("/");
+}
+
+/**
+ * Parse non-negative integer id
+ */
+export function parseId(id: string | undefined): number {
+  const numberValue = Number(id);
+  if (!isPositiveInteger(numberValue)) {
+    throw new InvalidIdException(id);
+  }
+  return numberValue;
+}
+
+export function abbreviateHeader(header: string) {
+  return header.length > 13 ? header.slice(0, 11) + "\u2026" : header;
+}
+
+export function isPositiveInteger(numberValue: number) {
+  return !isNaN(numberValue) && Number.isInteger(numberValue) && numberValue >= 0;
+}
+
+/**
+ * Validates that interval left and/or right values are integers or floats
+ *
+ * @return validation error message or undefined if interval is valid
+ */
+export function validateIntervalInput(
+  id: string,
+  left: string | undefined,
+  right: string | undefined,
+): string | undefined {
+  const leftNum = Number(left);
+  const rightNum = Number(right);
+
+  if (left && isNaN(leftNum)) {
+    return `Input 'from' (${left}) for filter '${id}' should be a number.`;
+  }
+  if (right && isNaN(rightNum)) {
+    return `Input 'to' (${right}) for filter '${id}' should be a number.`;
+  }
+  if (left && right && rightNum < leftNum) {
+    return `Input 'to' (${right}) for filter '${id}' should have a higher value than the 'from' input (${left}).`;
+  }
 }

package/src/utils/variantType.ts

@@ -0,0 +1,43 @@
+import { ValueString } from "@molgenis/vip-report-vcf";
+
+export type VariantTypeId = "all" | "snv" | "str" | "sv";
+export type VariantType = {
+  id: VariantTypeId;
+  label: string;
+  description: string;
+};
+
+const variantTypeMap: { [key: string]: VariantType } = {
+  all: { id: "all", label: "All", description: "All variants" },
+  snv: { id: "snv", label: "SNV", description: "Single nucleotide variants and Indels < 50 bases" },
+  str: { id: "str", label: "STR", description: "Short tandem repeats" },
+  sv: { id: "sv", label: "SV/CNV", description: "Structural variants including copy number variants" },
+};
+
+export function getVariantTypes(variantTypeIds: Set<VariantTypeId>): VariantType[] {
+  return Object.values(variantTypeMap).filter((variantType) => variantTypeIds.has(variantType.id));
+}
+
+export function parseVariantType(variantTypeId: string | undefined): VariantType {
+  if (variantTypeId === undefined) {
+    throw new Error();
+  }
+
+  const variantType = variantTypeMap[variantTypeId];
+  if (variantType === undefined) {
+    throw new Error(`unknown variant type '${variantTypeId}'`);
+  }
+  return variantType;
+}
+
+export function mapSvTypeToVariantTypeId(svType: ValueString | undefined): VariantTypeId {
+  let variantType: VariantTypeId;
+  if (svType === undefined || svType === null) {
+    variantType = "snv";
+  } else if (svType === "STR") {
+    variantType = "str";
+  } else {
+    variantType = "sv";
+  }
+  return variantType;
+}

package/src/utils/vcf.ts

@@ -0,0 +1,352 @@
+import {
+  FieldId,
+  FieldMetadata,
+  Genotype,
+  InfoContainer,
+  RecordSample,
+  Value,
+  ValueDescription,
+  ValueString,
+  VcfMetadata,
+  VcfRecord,
+} from "@molgenis/vip-report-vcf";
+import { Item } from "@molgenis/vip-report-api";
+import { SampleContainer, VcfMetadataContainer } from "./api.ts";
+import { ArrayIndexOutOfBoundsException, InvalidVcfError, RuntimeError } from "./error.ts";
+
+export type ValueCategorical =
+  | (ValueDescription & {
+      value: ValueString;
+    })
+  | null;
+export type FieldValue = Value | Genotype | ValueCategorical | ValueCategorical[];
+
+export type FieldMetadataWrapper = FieldMetadata & {
+  index: number;
+};
+export type FieldPath = string;
+export type FieldMap = { [key: FieldPath]: FieldMetadataWrapper };
+
+export function createFieldMap(metadata: VcfMetadata): FieldMap {
+  const infoFields = createFieldMapTypedRec("INFO", Object.values(metadata.info));
+  const formatFields = createFieldMapTypedRec("FORMAT", Object.values(metadata.format));
+  return { ...infoFields, ...formatFields };
+}
+
+function createFieldMapTypedRec(keyPrefix: string, fieldMetadataList: FieldMetadata[]): FieldMap {
+  const fields: { [key: string]: FieldMetadataWrapper } = {};
+  fieldMetadataList.forEach((fieldMetadata, index) => {
+    const key = `${keyPrefix}/${fieldMetadata.id}`;
+    if (fieldMetadata.nested) {
+      const nestedFields = createFieldMapTypedRec(key, fieldMetadata.nested.items);
+      Object.assign(fields, nestedFields);
+
+      // add parent field, but update items with items in nestedFields
+      fields[key] = {
+        ...fieldMetadata,
+        index,
+        nested: {
+          ...fieldMetadata.nested,
+          items: fieldMetadata.nested.items.map((field) => nestedFields[`${key}/${field.id}`]!),
+        },
+      };
+    } else {
+      fields[key] = { ...fieldMetadata, index };
+    }
+  });
+  return fields;
+}
+
+function mapFieldValueDefined(value: Value | Genotype, fieldMetadata: FieldMetadataWrapper): FieldValue {
+  let mappedValue: FieldValue;
+
+  if (fieldMetadata.type === "CATEGORICAL") {
+    // map categorical values to categories with label and description
+    if (fieldMetadata.number.count === 1) {
+      const valueString = value as ValueString;
+      mappedValue = createCategoricalValue(fieldMetadata, valueString);
+    } else {
+      if (!Array.isArray(value)) throw new RuntimeError();
+      const valueArray = value as ValueString[];
+      if (valueArray.length !== 0) {
+        mappedValue = valueArray.map((value) => createCategoricalValue(fieldMetadata, value));
+      } else {
+        // empty categorical array value should return array with nullValue if it is defined
+        mappedValue = fieldMetadata.nullValue ? [{ ...fieldMetadata.nullValue, value: null }] : [];
+      }
+    }
+  } else {
+    mappedValue = value;
+  }
+
+  return mappedValue;
+}
+
+function mapFieldValue(value: Value | Genotype | undefined, fieldMetadata: FieldMetadataWrapper): FieldValue {
+  let definedValue: Value | Genotype;
+  if (fieldMetadata.number.count === 1) {
+    definedValue = value !== undefined ? value : null;
+  } else {
+    definedValue = value !== undefined && value !== null ? value : [];
+  }
+  return mapFieldValueDefined(definedValue, fieldMetadata);
+}
+
+function getFieldValue(
+  valueContainer: ValueContainer,
+  valueIndex: number,
+  fieldMetadata: FieldMetadataWrapper,
+): FieldValue {
+  let value: Value | Genotype | undefined;
+  if (fieldMetadata.parent) {
+    if (fieldMetadata.parent.id in valueContainer) {
+      const parentValue = valueContainer[fieldMetadata.parent.id]!;
+      if (!Array.isArray(parentValue)) throw new InvalidVcfError();
+      const parentValueArray = parentValue as Value[];
+
+      if (fieldMetadata.parent.number.count === 1) {
+        if (parentValueArray.length < fieldMetadata.index) throw new InvalidVcfError();
+        value = parentValueArray[fieldMetadata.index]!;
+      } else {
+        if (parentValueArray.length < valueIndex) throw new RuntimeError();
+        const multiValue = parentValueArray[valueIndex]!;
+        if (!Array.isArray(multiValue)) throw new InvalidVcfError();
+        const multiValueArray = multiValue as Value[];
+
+        if (multiValueArray.length < fieldMetadata.index) throw new InvalidVcfError();
+        value = multiValueArray[fieldMetadata.index]!;
+      }
+    } else {
+      value = undefined;
+    }
+  } else {
+    if (fieldMetadata.id in valueContainer) {
+      value = valueContainer[fieldMetadata.id]!;
+    } else {
+      value = undefined;
+    }
+  }
+
+  return mapFieldValue(value, fieldMetadata);
+}
+
+function getFieldValues(
+  valueContainer: ValueContainer,
+  valueIndex: number,
+  ...fieldMetadataList: (FieldMetadataWrapper | undefined)[]
+): (FieldValue | undefined)[] {
+  return fieldMetadataList.map(
+    (fieldMetadata) => fieldMetadata && getFieldValue(valueContainer, valueIndex, fieldMetadata),
+  );
+}
+
+export function getInfoValue(
+  record: Item<VcfRecord>,
+  valueIndex: number,
+  fieldMetadata: FieldMetadataWrapper | undefined,
+): FieldValue | undefined {
+  const valueContainer: ValueContainer = record.data.n;
+  return fieldMetadata && getFieldValue(valueContainer, valueIndex, fieldMetadata);
+}
+
+export function getInfoValues(
+  record: Item<VcfRecord>,
+  valueIndex: number,
+  ...fieldMetadataList: (FieldMetadataWrapper | undefined)[]
+): (FieldValue | undefined)[] {
+  const valueContainer: ValueContainer = record.data.n;
+  return getFieldValues(valueContainer, valueIndex, ...fieldMetadataList);
+}
+
+export function getSampleValue(
+  sample: SampleContainer,
+  record: Item<VcfRecord>,
+  valueIndex: number,
+  fieldMetadata: FieldMetadataWrapper | undefined,
+): FieldValue | Genotype | undefined {
+  const valueContainer: ValueContainer = getRecordSample(sample, record);
+  return fieldMetadata && getFieldValue(valueContainer, valueIndex, fieldMetadata);
+}
+
+export function getSampleValues(
+  sample: SampleContainer,
+  record: Item<VcfRecord>,
+  valueIndex: number,
+  ...fieldMetadataList: (FieldMetadataWrapper | undefined)[]
+): (FieldValue | Genotype | undefined)[] {
+  const valueContainer: ValueContainer = getRecordSample(sample, record);
+  return getFieldValues(valueContainer, valueIndex, ...fieldMetadataList);
+}
+
+export const isNumerical = (fieldMetadata: FieldMetadata): boolean => {
+  return fieldMetadata.type === "FLOAT" || fieldMetadata.type === "INTEGER";
+};
+
+function createCategoricalValue(infoMetadata: FieldMetadata, value: ValueString): ValueCategorical {
+  if (infoMetadata.categories === undefined) throw new RuntimeError();
+
+  let valueDescription: ValueDescription | null;
+  if (value !== null) {
+    if (!(value in infoMetadata.categories)) {
+      throw new RuntimeError(
+        `invalid categorical field '${infoMetadata.id}' value '${value}' is not one of [${Object.keys(infoMetadata.categories).join(", ")}]`,
+      );
+    }
+    valueDescription = infoMetadata.categories[value]!;
+  } else {
+    valueDescription = infoMetadata.nullValue || null;
+  }
+  return valueDescription && { ...valueDescription, value };
+}
+
+function getRecordSample(sample: SampleContainer, record: Item<VcfRecord>): RecordSample {
+  const recordSample = record.data.s[sample.item.data.index];
+  if (recordSample === undefined) throw new ArrayIndexOutOfBoundsException();
+  return recordSample;
+}
+
+type ValueContainer = InfoContainer | RecordSample;
+
+/**
+ * Returns number of values for info field or for parent info field if exists
+ */
+export function getInfoValueCount(record: Item<VcfRecord>, fieldMetadata: FieldMetadata): number {
+  const valueContainer: ValueContainer = record.data.n;
+  return getFieldValueCount(fieldMetadata, valueContainer);
+}
+
+/**
+ * Returns number of values for sample field or for parent sample field if exists
+ */
+export function getSampleValueCount(
+  sample: SampleContainer,
+  record: Item<VcfRecord>,
+  fieldMetadata: FieldMetadata,
+): number {
+  const valueContainer: ValueContainer = getRecordSample(sample, record);
+  return getFieldValueCount(fieldMetadata, valueContainer);
+}
+
+function getFieldValueCount(fieldMetadata: FieldMetadata, valueContainer: ValueContainer): number {
+  let count: number;
+
+  const parentFieldMetadata = fieldMetadata.parent;
+  if (parentFieldMetadata && parentFieldMetadata.number.count !== 1) {
+    if (parentFieldMetadata.id in valueContainer) {
+      const value = valueContainer[parentFieldMetadata.id]!;
+      if (!Array.isArray(value)) throw new RuntimeError();
+      count = (value as Value[]).length;
+    } else {
+      count = 0;
+    }
+  } else {
+    count = 1;
+  }
+  return count;
+}
+
+export function getInfoNestedField(
+  metadata: VcfMetadataContainer,
+  parentFieldId: FieldId,
+  fieldId: FieldId,
+): FieldMetadataWrapper | undefined {
+  return getInfoNestedFields(metadata, parentFieldId, fieldId)[0];
+}
+
+export function getInfoNestedFields(
+  metadata: VcfMetadataContainer,
+  parentFieldId: FieldId,
+  ...fieldIds: FieldId[]
+): (FieldMetadataWrapper | undefined)[] {
+  return getFields(metadata, `INFO/${parentFieldId}`, ...fieldIds);
+}
+
+export function getInfoField(metadata: VcfMetadataContainer, fieldId: FieldId): FieldMetadataWrapper | undefined {
+  return getField(metadata, "INFO", fieldId);
+}
+
+export function getInfoFields(
+  metadata: VcfMetadataContainer,
+  ...fieldIds: FieldId[]
+): (FieldMetadataWrapper | undefined)[] {
+  return getFields(metadata, "INFO", ...fieldIds);
+}
+
+export function getInfoFieldsRegex(metadata: VcfMetadataContainer, regex: RegExp): FieldMetadataWrapper[] {
+  return getFieldsRegex(metadata, "INFO", regex);
+}
+
+export function getSampleField(metadata: VcfMetadataContainer, fieldId: FieldId): FieldMetadataWrapper | undefined {
+  return getField(metadata, "FORMAT", fieldId);
+}
+
+export function getSampleFields(
+  metadata: VcfMetadataContainer,
+  ...fieldIds: FieldId[]
+): (FieldMetadataWrapper | undefined)[] {
+  return getFields(metadata, "FORMAT", ...fieldIds);
+}
+
+export function getSampleNestedField(
+  metadata: VcfMetadataContainer,
+  parentFieldId: FieldId,
+  fieldId: FieldId,
+): FieldMetadataWrapper | undefined {
+  return getSampleNestedFields(metadata, parentFieldId, fieldId)[0];
+}
+
+export function getSampleNestedFields(
+  metadata: VcfMetadataContainer,
+  parentFieldId: FieldId,
+  ...fieldIds: FieldId[]
+): (FieldMetadataWrapper | undefined)[] {
+  return getFields(metadata, `FORMAT/${parentFieldId}`, ...fieldIds);
+}
+
+export function getSampleFieldsRegex(metadata: VcfMetadataContainer, regex: RegExp): FieldMetadataWrapper[] {
+  return getFieldsRegex(metadata, "FORMAT", regex);
+}
+
+function getFields(
+  metadata: VcfMetadataContainer,
+  prefix: string,
+  ...fieldIds: FieldId[]
+): (FieldMetadataWrapper | undefined)[] {
+  return fieldIds.map((fieldId) => getField(metadata, prefix, fieldId));
+}
+
+function getField(metadata: VcfMetadataContainer, prefix: string, fieldId: FieldId): FieldMetadataWrapper | undefined {
+  return metadata.fieldMap[`${prefix}/${fieldId}`];
+}
+
+function getFieldsRegex(metadata: VcfMetadataContainer, prefix: string, regex: RegExp): FieldMetadataWrapper[] {
+  return Object.entries(metadata.fieldMap)
+    .filter(([key]) => key.startsWith(`${prefix}/`) && regex.test(key.substring(`${prefix}/`.length)))
+    .map(([, value]) => value);
+}
+
+export function parseContigIds(metadata: VcfMetadata): string[] {
+  return metadata.lines
+    .filter((line) => line.startsWith("##contig="))
+    .map((line) => {
+      const tokens: { [index: string]: string } = {};
+      for (const token of line.substring(10, line.length - 1).split(",")) {
+        const keyValue = token.split("=");
+        if (keyValue.length !== 2) throw new InvalidVcfError();
+        tokens[keyValue[0]!] = keyValue[1]!;
+      }
+      const token = tokens["ID"];
+      if (token === undefined) throw new InvalidVcfError();
+      return token;
+    });
+}
+
+export function getHeaderValue(metadata: VcfMetadata, key: string): string | null {
+  const token = `##${key}=`;
+  for (const line of metadata.lines) {
+    if (line.startsWith(token)) {
+      return line.substring(token.length);
+    }
+  }
+  return null;
+}