@biblioteksentralen/marc 0.0.1

package/README.md

@@ -0,0 +1,79 @@
+# `@biblioteksentralen/marc`
+
+Package for representating MARC records in TypeScript and serialize to/from MARC XML and JSON.
+
+The JSON serialization is compatible with schema defined by <https://www.npmjs.com/package/@natlibfi/marc-record>
+
+## Usage
+
+### Parsing XML
+
+```ts
+import { parseMarcXml } from "@biblioteksentralen/marc";
+
+const xmlRecord = `
+<record xmlns="http://www.loc.gov/MARC21/slim">
+  <leader>00000cam^a22001937i^4500</leader>
+  <controlfield tag="001">000030000</controlfield>
+  <controlfield tag="003">FI-MELINDA</controlfield>
+  <controlfield tag="005">20141221175522.0</controlfield>
+  <controlfield tag="008">890208s1988^^^^sw^|||||||||||||||||swe||</controlfield>
+  <datafield tag="020" ind1=" " ind2=" ">
+    <subfield code="a">91-38-61844-3</subfield>
+    <subfield code="q">inb.</subfield>
+  </datafield>
+  <datafield tag="100" ind1="0" ind2=" ">
+    <subfield code="a">Durö, Robert.</subfield>
+  </datafield>
+  <datafield tag="245" ind1="1" ind2="0">
+    <subfield code="a">Konkurrensöverlägsenhet :</subfield>
+    <subfield code="b">i tio konkreta steg /</subfield>
+    <subfield code="c">Robert Durö.</subfield>
+  </datafield>
+</record>
+`;
+
+const record = parseMarcXml(xmlRecord);
+const title = record
+  .getSubfieldValues("245", /a|b|n|p/)
+  .join(" ")
+  ?.trim();
+```
+
+### Serializing / deserializing
+
+The MarcRecord class can be JSON serialized:
+
+```ts
+const serializedRecord = JSON.stringify(record);
+```
+
+and deserialized:
+
+```ts
+const record = MarcRecord.fromJSON(JSON.parse(serializedRecord));
+```
+
+Standalone fields can also be deserialized using the `createDataField` function – useful for tests:
+
+```ts
+const field = createDataField({
+  tag: "020",
+  subfields: [{ code: "a", value: "9788283982701" }],
+});
+```
+
+### JSON Schema validation
+
+The package exports a JSON schema that can be used to validate JSON serialized
+MARC record structure using AJV or other JSON Schema validators.
+
+```ts
+import Ajv from "ajv";
+import { createMarcSchema } from "@biblioteksentralen/marc";
+
+const schema = createMarcSchema();
+const ajv = new Ajv();
+const validate = ajv.compile(schema);
+const result = validate(record.toJSON());
+```

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+import xpath from 'xpath';
+import { Logger } from 'ts-log';
+
+type SerializedMarcField = SerializedDataField | SerializedControlField;
+interface SerializedControlField {
+    tag: string;
+    value: string;
+}
+interface SerializedDataField {
+    tag: string;
+    ind1?: string;
+    ind2?: string;
+    subfields: SerializedMarcSubfield[];
+}
+interface SerializedMarcSubfield {
+    code: string;
+    value: string;
+}
+declare class Subfield {
+    readonly code: string;
+    readonly value: string;
+    constructor(code: string, value: string);
+    toJSON(): SerializedMarcSubfield;
+    toString(): string;
+}
+declare class ControlField {
+    readonly tag: string;
+    readonly value: string;
+    constructor(tag: string, value: string);
+    toJSON(): SerializedControlField;
+    toString(): string;
+}
+declare class DataField {
+    readonly tag: string;
+    readonly ind1: string | undefined;
+    readonly ind2: string | undefined;
+    readonly subfields: Subfield[];
+    constructor(tag: string, ind1: string | undefined, ind2: string | undefined, subfields: Subfield[]);
+    getSubfields(code?: string | RegExp): Subfield[];
+    getFirstSubfield(code: string | RegExp): Subfield | undefined;
+    getFirstSubfieldValue(code: string | RegExp): string | undefined;
+    toJSON(): SerializedDataField;
+    toString(): string;
+}
+type MarcField = ControlField | DataField;
+declare const createDataField: (field: SerializedDataField) => DataField;
+declare const createControlField: (field: SerializedControlField) => ControlField;
+
+type Indicators = {
+    ind1?: string;
+    ind2?: string;
+};
+interface SerializedMarcRecord {
+    format?: string;
+    leader: string;
+    fields: SerializedMarcField[];
+}
+declare class MarcRecord {
+    readonly format: string | undefined;
+    readonly leader: string;
+    readonly fields: MarcField[];
+    constructor({ leader, fields, format, }: {
+        leader: string;
+        fields: MarcField[];
+        format?: string;
+    });
+    static fromJSON(data: unknown): MarcRecord;
+    static validateJSON(data: unknown): SerializedMarcRecord;
+    getControlFields(): ControlField[];
+    getControlField(tag: string): ControlField | undefined;
+    getDataFields(tag?: string | RegExp, indicators?: Indicators): DataField[];
+    getFirstDataField(tag: string | RegExp, indicators?: Indicators): DataField | undefined;
+    getSubfields(tag: string | RegExp, code: string | RegExp, indicators?: Indicators): Subfield[];
+    getSubfieldValues(tag: string | RegExp, code: string | RegExp, indicators?: Indicators): string[];
+    getFirstSubfieldValue(tag: string | RegExp, code: string | RegExp, indicators?: Indicators): string | undefined;
+    toJSON(): SerializedMarcRecord;
+    toString(): string;
+}
+
+interface MarcXmlOptions {
+    namespace?: string;
+    /**
+     * Callback function to transform or filter control fields.
+     */
+    processControlField?: (field: ControlField) => ControlField | undefined;
+    /**
+     * Callback function to transform or filter data fields.
+     */
+    processDataField?: (field: DataField) => DataField | undefined;
+    /**
+     * Free-form string that specifies the MARC record flavour.
+     */
+    format?: string;
+}
+declare function parseMarcXml(input: string, options?: MarcXmlOptions): MarcRecord[];
+
+type NamespaceMap = Record<string, string>;
+interface ParseOptions {
+    log?: Logger;
+    namespaces?: NamespaceMap;
+}
+declare function parseXml(xmlText: string, { log, namespaces }?: ParseOptions): XmlElement;
+/**
+ * XPath-focused helper class for extracting information from an XML document.
+ */
+declare class XmlElement {
+    readonly node: Document | Element;
+    protected namespaces: NamespaceMap;
+    protected select: xpath.XPathSelect;
+    constructor(node: Document | Element, namespaces?: NamespaceMap);
+    toString(): string;
+    /**
+     * Get the underlying Element node. Returns undefined if the underlying
+     * node is the root Document node.
+     */
+    get element(): Element | undefined;
+    /**
+     * Get namespaces used in XPath queries.
+     */
+    getNamespaces(): NamespaceMap;
+    /**
+     * Find anything (nodes, text, etc.) by xpath.
+     * @param {string} query - XPath query.
+     */
+    query(query: string): xpath.SelectedValue[];
+    /**
+     * Find element nodes by XPath query.
+     * @param {string} query - XPath query.
+     */
+    elements(query: string): XmlElement[];
+    /**
+     * Get text content of the current node or the *first* result matched by an XPath query.
+     * @param {string} query - XPath query.
+     */
+    text(query?: string): string | undefined;
+    /**
+     * Get atribute value of the current node.
+     * @param {string} name - Attribute name
+     */
+    attr(name: string): string | null | undefined;
+}
+
+export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, XmlElement, createControlField, createDataField, parseMarcXml, parseXml };

package/dist/index.js

@@ -0,0 +1,429 @@
+'use strict';
+
+var xmldom = require('@xmldom/xmldom');
+var xpath = require('xpath');
+var Ajv = require('ajv');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var xpath__default = /*#__PURE__*/_interopDefault(xpath);
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
+// src/xml-element/XmlElement.ts
+
+// src/xml-element/NodeType.ts
+var NodeType = {
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  TEXT_NODE: 3,
+  CDATA_SECTION_NODE: 4,
+  ENTITY_REFERENCE_NODE: 5,
+  ENTITY_NODE: 6,
+  PROCESSING_INSTRUCTION_NODE: 7,
+  COMMENT_NODE: 8,
+  DOCUMENT_NODE: 9,
+  DOCUMENT_TYPE_NODE: 1,
+  DOCUMENT_FRAGMENT_NODE: 1,
+  NOTATION_NODE: 1
+};
+var isNode = (value) => typeof value === "object" && value !== null && "nodeType" in value;
+var isElementNode = (node) => isNode(node) && node.nodeType === NodeType.ELEMENT_NODE;
+
+// src/xml-element/XmlElement.ts
+var InvalidXml = class extends Error {
+};
+function parseXml(xmlText, { log = console, namespaces = {} } = {}) {
+  const errorHandler = (error) => {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new InvalidXml(
+      `Failed to parse XML response: "${xmlText}". Error: "${errorMsg}"`
+    );
+  };
+  const doc = new xmldom.DOMParser({
+    errorHandler: {
+      warning: (msg) => log.warn(msg),
+      error: errorHandler,
+      fatalError: errorHandler
+    }
+  }).parseFromString(xmlText, "text/xml");
+  return new XmlElement(doc, namespaces);
+}
+var XmlElement = class _XmlElement {
+  node;
+  namespaces;
+  select;
+  constructor(node, namespaces = {}) {
+    this.node = node;
+    this.namespaces = namespaces;
+    this.select = xpath__default.default.useNamespaces(namespaces);
+  }
+  toString() {
+    return new xmldom.XMLSerializer().serializeToString(this.node);
+  }
+  /**
+   * Get the underlying Element node. Returns undefined if the underlying
+   * node is the root Document node.
+   */
+  get element() {
+    return isElementNode(this.node) ? this.node : void 0;
+  }
+  /**
+   * Get namespaces used in XPath queries.
+   */
+  getNamespaces() {
+    return this.namespaces;
+  }
+  /**
+   * Find anything (nodes, text, etc.) by xpath.
+   * @param {string} query - XPath query.
+   */
+  query(query) {
+    return this.select(query, this.node);
+  }
+  /**
+   * Find element nodes by XPath query.
+   * @param {string} query - XPath query.
+   */
+  elements(query) {
+    return this.query(query).filter(isElementNode).map((elementNode) => new _XmlElement(elementNode, this.namespaces));
+  }
+  /**
+   * Get text content of the current node or the *first* result matched by an XPath query.
+   * @param {string} query - XPath query.
+   */
+  text(query) {
+    if (!query) {
+      return this.node.textContent ? this.node.textContent : void 0;
+    }
+    return this.elements(query)[0]?.text();
+  }
+  /**
+   * Get atribute value of the current node.
+   * @param {string} name - Attribute name
+   */
+  attr(name) {
+    return isElementNode(this.node) ? this.node.getAttribute(name) : void 0;
+  }
+};
+
+// src/marc-record/MarcField.ts
+var Subfield = class {
+  constructor(code, value) {
+    this.code = code;
+    this.value = value;
+  }
+  toJSON() {
+    return { code: this.code, value: this.value };
+  }
+  toString() {
+    return `$${this.code} ${this.value}`;
+  }
+};
+var ControlField = class {
+  constructor(tag, value) {
+    this.tag = tag;
+    this.value = value;
+  }
+  toJSON() {
+    return { tag: this.tag, value: this.value };
+  }
+  toString() {
+    return `${this.tag} ${this.value}`;
+  }
+};
+var DataField = class {
+  constructor(tag, ind1, ind2, subfields) {
+    this.tag = tag;
+    this.ind1 = ind1;
+    this.ind2 = ind2;
+    this.subfields = subfields;
+  }
+  getSubfields(code) {
+    return typeof code === "undefined" ? this.subfields : this.subfields.filter(
+      (subfield) => matchFullString(subfield.code, code)
+    );
+  }
+  getFirstSubfield(code) {
+    return this.subfields.find(
+      (subfield) => matchFullString(subfield.code, code)
+    );
+  }
+  getFirstSubfieldValue(code) {
+    return this.getFirstSubfield(code)?.value;
+  }
+  toJSON() {
+    return {
+      tag: this.tag,
+      ind1: this.ind1,
+      ind2: this.ind2,
+      subfields: this.subfields.map((subfield) => subfield.toJSON())
+    };
+  }
+  toString() {
+    return `${this.tag} ${this.subfields.map((subfield) => subfield.toString()).join(" ")}`;
+  }
+};
+var isControlField = (field) => field instanceof ControlField;
+var isDataField = (field) => field instanceof DataField;
+var matchFullString = (value, pattern) => pattern instanceof RegExp ? (
+  // Rewrite RegExp to match the full string
+  value.match(new RegExp(`^(?:${pattern.source})$`, pattern.flags))
+) : value === pattern;
+var createDataField = (field) => new DataField(
+  field.tag,
+  field.ind1,
+  field.ind2,
+  field.subfields.map((sf) => new Subfield(sf.code, sf.value))
+);
+var createControlField = (field) => new ControlField(field.tag, field.value);
+
+// src/marc-record/fixInvalidMarcRecordSerialization.ts
+var fixInvalidMarcRecordSerialization = (data) => data && typeof data === "object" && "fields" in data && Array.isArray(data.fields) ? {
+  ...data,
+  fields: data.fields.map(
+    (field) => field && typeof field === "object" && "ind1" in field && "ind2" in field ? {
+      ...field,
+      ind1: field.ind1 === "" ? " " : field.ind1,
+      ind2: field.ind2 === "" ? " " : field.ind2
+    } : field
+  )
+} : data;
+
+// src/marc-record/schema.ts
+function createMarcSchema({
+  /**
+   * Require at least one field to be present. Defaults to true.
+   */
+  requireFields = true,
+  /**
+   * Require at least one subfield per data field to be present. Defaults to true.
+   */
+  requireSubfields = true,
+  /**
+   * Require a subfield value for each subfield. Defaults to true.
+   */
+  requireSubfieldValue = true
+} = {}) {
+  return {
+    type: "object",
+    properties: {
+      format: {
+        type: "string"
+      },
+      leader: {
+        type: "string"
+      },
+      fields: {
+        type: "array",
+        minItems: requireFields ? 1 : 0,
+        items: {
+          anyOf: [
+            {
+              type: "object",
+              properties: {
+                tag: {
+                  type: "string",
+                  minLength: 1
+                },
+                value: {
+                  type: "string",
+                  minLength: 1
+                }
+              },
+              required: ["tag", "value"]
+            },
+            {
+              type: "object",
+              properties: {
+                tag: {
+                  type: "string",
+                  minLength: 1
+                },
+                ind1: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 1
+                },
+                ind2: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 1
+                },
+                subfields: {
+                  type: "array",
+                  minItems: requireSubfields ? 1 : 0,
+                  items: {
+                    type: "object",
+                    properties: {
+                      code: {
+                        type: "string",
+                        minLength: 1
+                      },
+                      value: {
+                        type: "string",
+                        minLength: requireSubfieldValue ? 1 : 0
+                      }
+                    },
+                    required: requireSubfieldValue ? ["code", "value"] : ["code"]
+                  }
+                }
+              },
+              required: ["tag", "ind1", "ind2", "subfields"]
+            }
+          ]
+        }
+      }
+    },
+    required: ["leader", "fields"]
+  };
+}
+
+// src/marc-record/MarcRecord.ts
+var ValidationFailed = class extends Error {
+  constructor(errors) {
+    super("MarcRecord validation failed");
+    this.errors = errors;
+  }
+};
+var MarcRecord = class _MarcRecord {
+  format;
+  leader;
+  fields;
+  constructor({
+    leader,
+    fields,
+    format
+  }) {
+    this.format = format;
+    this.leader = leader;
+    this.fields = fields;
+  }
+  static fromJSON(data) {
+    const { format, leader, fields } = this.validateJSON(
+      fixInvalidMarcRecordSerialization(data)
+    );
+    return new _MarcRecord({
+      leader,
+      format,
+      fields: fields.map(
+        (field) => "subfields" in field ? createDataField(field) : createControlField(field)
+      )
+    });
+  }
+  static validateJSON(data) {
+    const schema = createMarcSchema();
+    const ajv = new Ajv__default.default();
+    const validator = ajv.compile(schema);
+    if (validator(data)) {
+      return data;
+    }
+    throw new ValidationFailed(validator.errors ?? []);
+  }
+  getControlFields() {
+    return this.fields.filter(isControlField);
+  }
+  getControlField(tag) {
+    return this.getControlFields().find((field) => field.tag === tag);
+  }
+  getDataFields(tag, indicators) {
+    const dataFields = this.fields.filter(isDataField);
+    return dataFields.filter(
+      (field) => (typeof tag === "undefined" || matchFullString(field.tag, tag)) && (typeof indicators?.ind1 === "undefined" || indicators.ind1 === field.ind1) && (typeof indicators?.ind2 === "undefined" || indicators.ind2 === field.ind2)
+    );
+  }
+  getFirstDataField(tag, indicators) {
+    return this.getDataFields(tag, indicators)[0];
+  }
+  getSubfields(tag, code, indicators) {
+    return this.getDataFields(tag, indicators).flatMap((field) => field.getSubfields(code)).filter((subfield) => subfield.value !== "");
+  }
+  getSubfieldValues(tag, code, indicators) {
+    return this.getSubfields(tag, code, indicators).map(({ value }) => value);
+  }
+  getFirstSubfieldValue(tag, code, indicators) {
+    return this.getSubfieldValues(tag, code, indicators)[0];
+  }
+  toJSON() {
+    return {
+      format: this.format,
+      leader: this.leader,
+      fields: this.fields.map((field) => field.toJSON())
+    };
+  }
+  toString() {
+    return this.fields.map((field) => field.toString()).join("\n");
+  }
+};
+
+// src/marc-record/namespace.ts
+var marcXmlNamespaces = [
+  // The original MARC 21 XML schema (2002)
+  "http://www.loc.gov/MARC21/slim",
+  // Version 1 of the ISO 25577 MarcXchange schema (2007) is for all practical purposes
+  // the same schema as the original MARC 21 XML schema, but weakens restrictions to support
+  // other dialects than MARC 21 (not excluding the most esoteric ones).
+  "info:lc/xmlns/marcxchange-v1",
+  // Version 2 of MarcXchange adds support of embedded data, one of the many
+  // advanced XML features that a poor developer hopes not to encounter in the wild.
+  // Also weakens restrictions even further so that even a completely empty record is valid.
+  "info:lc/xmlns/marcxchange-v2"
+];
+function detectNamespace(input) {
+  for (const possibleNamespace of marcXmlNamespaces) {
+    if (input.indexOf(possibleNamespace) !== -1) {
+      return possibleNamespace;
+    }
+  }
+  return "";
+}
+
+// src/marc-record/parseMarcXml.ts
+function parseMarcXml(input, options = {}) {
+  const namespace = options.namespace ?? detectNamespace(input);
+  const xmlRecord = parseXml(input, {
+    namespaces: {
+      marc: namespace
+    }
+  });
+  const processControlField = options.processControlField ?? ((field) => field);
+  const processDataField = options.processDataField ?? ((field) => field);
+  return xmlRecord.elements("//marc:record").map((marcRecord) => {
+    const leader = marcRecord.text("marc:leader") ?? "";
+    const fields = marcRecord.elements("marc:controlfield | marc:datafield").reduce((fields2, field) => {
+      const tag = field.attr("tag");
+      if (!tag)
+        return fields2;
+      if (field.element?.localName === "controlfield") {
+        const newField = processControlField(
+          new ControlField(tag, field.text() ?? "")
+        );
+        return newField ? [...fields2, newField] : fields2;
+      } else {
+        const subfields = field.elements("marc:subfield").reduce((subfields2, subfield) => {
+          const code = subfield.attr("code");
+          return code ? [...subfields2, new Subfield(code, subfield.text() ?? "")] : subfields2;
+        }, []);
+        const newField = processDataField(
+          new DataField(
+            tag,
+            field.attr("ind1") ?? void 0,
+            field.attr("ind2") ?? void 0,
+            subfields
+          )
+        );
+        return newField ? [...fields2, newField] : fields2;
+      }
+    }, []);
+    return new MarcRecord({ leader, fields, format: options.format });
+  });
+}
+
+exports.ControlField = ControlField;
+exports.DataField = DataField;
+exports.MarcRecord = MarcRecord;
+exports.Subfield = Subfield;
+exports.XmlElement = XmlElement;
+exports.createControlField = createControlField;
+exports.createDataField = createDataField;
+exports.parseMarcXml = parseMarcXml;
+exports.parseXml = parseXml;

package/dist/index.mjs

@@ -0,0 +1,414 @@
+import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
+import xpath from 'xpath';
+import Ajv from 'ajv';
+
+// src/xml-element/XmlElement.ts
+
+// src/xml-element/NodeType.ts
+var NodeType = {
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  TEXT_NODE: 3,
+  CDATA_SECTION_NODE: 4,
+  ENTITY_REFERENCE_NODE: 5,
+  ENTITY_NODE: 6,
+  PROCESSING_INSTRUCTION_NODE: 7,
+  COMMENT_NODE: 8,
+  DOCUMENT_NODE: 9,
+  DOCUMENT_TYPE_NODE: 1,
+  DOCUMENT_FRAGMENT_NODE: 1,
+  NOTATION_NODE: 1
+};
+var isNode = (value) => typeof value === "object" && value !== null && "nodeType" in value;
+var isElementNode = (node) => isNode(node) && node.nodeType === NodeType.ELEMENT_NODE;
+
+// src/xml-element/XmlElement.ts
+var InvalidXml = class extends Error {
+};
+function parseXml(xmlText, { log = console, namespaces = {} } = {}) {
+  const errorHandler = (error) => {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new InvalidXml(
+      `Failed to parse XML response: "${xmlText}". Error: "${errorMsg}"`
+    );
+  };
+  const doc = new DOMParser({
+    errorHandler: {
+      warning: (msg) => log.warn(msg),
+      error: errorHandler,
+      fatalError: errorHandler
+    }
+  }).parseFromString(xmlText, "text/xml");
+  return new XmlElement(doc, namespaces);
+}
+var XmlElement = class _XmlElement {
+  node;
+  namespaces;
+  select;
+  constructor(node, namespaces = {}) {
+    this.node = node;
+    this.namespaces = namespaces;
+    this.select = xpath.useNamespaces(namespaces);
+  }
+  toString() {
+    return new XMLSerializer().serializeToString(this.node);
+  }
+  /**
+   * Get the underlying Element node. Returns undefined if the underlying
+   * node is the root Document node.
+   */
+  get element() {
+    return isElementNode(this.node) ? this.node : void 0;
+  }
+  /**
+   * Get namespaces used in XPath queries.
+   */
+  getNamespaces() {
+    return this.namespaces;
+  }
+  /**
+   * Find anything (nodes, text, etc.) by xpath.
+   * @param {string} query - XPath query.
+   */
+  query(query) {
+    return this.select(query, this.node);
+  }
+  /**
+   * Find element nodes by XPath query.
+   * @param {string} query - XPath query.
+   */
+  elements(query) {
+    return this.query(query).filter(isElementNode).map((elementNode) => new _XmlElement(elementNode, this.namespaces));
+  }
+  /**
+   * Get text content of the current node or the *first* result matched by an XPath query.
+   * @param {string} query - XPath query.
+   */
+  text(query) {
+    if (!query) {
+      return this.node.textContent ? this.node.textContent : void 0;
+    }
+    return this.elements(query)[0]?.text();
+  }
+  /**
+   * Get atribute value of the current node.
+   * @param {string} name - Attribute name
+   */
+  attr(name) {
+    return isElementNode(this.node) ? this.node.getAttribute(name) : void 0;
+  }
+};
+
+// src/marc-record/MarcField.ts
+var Subfield = class {
+  constructor(code, value) {
+    this.code = code;
+    this.value = value;
+  }
+  toJSON() {
+    return { code: this.code, value: this.value };
+  }
+  toString() {
+    return `$${this.code} ${this.value}`;
+  }
+};
+var ControlField = class {
+  constructor(tag, value) {
+    this.tag = tag;
+    this.value = value;
+  }
+  toJSON() {
+    return { tag: this.tag, value: this.value };
+  }
+  toString() {
+    return `${this.tag} ${this.value}`;
+  }
+};
+var DataField = class {
+  constructor(tag, ind1, ind2, subfields) {
+    this.tag = tag;
+    this.ind1 = ind1;
+    this.ind2 = ind2;
+    this.subfields = subfields;
+  }
+  getSubfields(code) {
+    return typeof code === "undefined" ? this.subfields : this.subfields.filter(
+      (subfield) => matchFullString(subfield.code, code)
+    );
+  }
+  getFirstSubfield(code) {
+    return this.subfields.find(
+      (subfield) => matchFullString(subfield.code, code)
+    );
+  }
+  getFirstSubfieldValue(code) {
+    return this.getFirstSubfield(code)?.value;
+  }
+  toJSON() {
+    return {
+      tag: this.tag,
+      ind1: this.ind1,
+      ind2: this.ind2,
+      subfields: this.subfields.map((subfield) => subfield.toJSON())
+    };
+  }
+  toString() {
+    return `${this.tag} ${this.subfields.map((subfield) => subfield.toString()).join(" ")}`;
+  }
+};
+var isControlField = (field) => field instanceof ControlField;
+var isDataField = (field) => field instanceof DataField;
+var matchFullString = (value, pattern) => pattern instanceof RegExp ? (
+  // Rewrite RegExp to match the full string
+  value.match(new RegExp(`^(?:${pattern.source})$`, pattern.flags))
+) : value === pattern;
+var createDataField = (field) => new DataField(
+  field.tag,
+  field.ind1,
+  field.ind2,
+  field.subfields.map((sf) => new Subfield(sf.code, sf.value))
+);
+var createControlField = (field) => new ControlField(field.tag, field.value);
+
+// src/marc-record/fixInvalidMarcRecordSerialization.ts
+var fixInvalidMarcRecordSerialization = (data) => data && typeof data === "object" && "fields" in data && Array.isArray(data.fields) ? {
+  ...data,
+  fields: data.fields.map(
+    (field) => field && typeof field === "object" && "ind1" in field && "ind2" in field ? {
+      ...field,
+      ind1: field.ind1 === "" ? " " : field.ind1,
+      ind2: field.ind2 === "" ? " " : field.ind2
+    } : field
+  )
+} : data;
+
+// src/marc-record/schema.ts
+function createMarcSchema({
+  /**
+   * Require at least one field to be present. Defaults to true.
+   */
+  requireFields = true,
+  /**
+   * Require at least one subfield per data field to be present. Defaults to true.
+   */
+  requireSubfields = true,
+  /**
+   * Require a subfield value for each subfield. Defaults to true.
+   */
+  requireSubfieldValue = true
+} = {}) {
+  return {
+    type: "object",
+    properties: {
+      format: {
+        type: "string"
+      },
+      leader: {
+        type: "string"
+      },
+      fields: {
+        type: "array",
+        minItems: requireFields ? 1 : 0,
+        items: {
+          anyOf: [
+            {
+              type: "object",
+              properties: {
+                tag: {
+                  type: "string",
+                  minLength: 1
+                },
+                value: {
+                  type: "string",
+                  minLength: 1
+                }
+              },
+              required: ["tag", "value"]
+            },
+            {
+              type: "object",
+              properties: {
+                tag: {
+                  type: "string",
+                  minLength: 1
+                },
+                ind1: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 1
+                },
+                ind2: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 1
+                },
+                subfields: {
+                  type: "array",
+                  minItems: requireSubfields ? 1 : 0,
+                  items: {
+                    type: "object",
+                    properties: {
+                      code: {
+                        type: "string",
+                        minLength: 1
+                      },
+                      value: {
+                        type: "string",
+                        minLength: requireSubfieldValue ? 1 : 0
+                      }
+                    },
+                    required: requireSubfieldValue ? ["code", "value"] : ["code"]
+                  }
+                }
+              },
+              required: ["tag", "ind1", "ind2", "subfields"]
+            }
+          ]
+        }
+      }
+    },
+    required: ["leader", "fields"]
+  };
+}
+
+// src/marc-record/MarcRecord.ts
+var ValidationFailed = class extends Error {
+  constructor(errors) {
+    super("MarcRecord validation failed");
+    this.errors = errors;
+  }
+};
+var MarcRecord = class _MarcRecord {
+  format;
+  leader;
+  fields;
+  constructor({
+    leader,
+    fields,
+    format
+  }) {
+    this.format = format;
+    this.leader = leader;
+    this.fields = fields;
+  }
+  static fromJSON(data) {
+    const { format, leader, fields } = this.validateJSON(
+      fixInvalidMarcRecordSerialization(data)
+    );
+    return new _MarcRecord({
+      leader,
+      format,
+      fields: fields.map(
+        (field) => "subfields" in field ? createDataField(field) : createControlField(field)
+      )
+    });
+  }
+  static validateJSON(data) {
+    const schema = createMarcSchema();
+    const ajv = new Ajv();
+    const validator = ajv.compile(schema);
+    if (validator(data)) {
+      return data;
+    }
+    throw new ValidationFailed(validator.errors ?? []);
+  }
+  getControlFields() {
+    return this.fields.filter(isControlField);
+  }
+  getControlField(tag) {
+    return this.getControlFields().find((field) => field.tag === tag);
+  }
+  getDataFields(tag, indicators) {
+    const dataFields = this.fields.filter(isDataField);
+    return dataFields.filter(
+      (field) => (typeof tag === "undefined" || matchFullString(field.tag, tag)) && (typeof indicators?.ind1 === "undefined" || indicators.ind1 === field.ind1) && (typeof indicators?.ind2 === "undefined" || indicators.ind2 === field.ind2)
+    );
+  }
+  getFirstDataField(tag, indicators) {
+    return this.getDataFields(tag, indicators)[0];
+  }
+  getSubfields(tag, code, indicators) {
+    return this.getDataFields(tag, indicators).flatMap((field) => field.getSubfields(code)).filter((subfield) => subfield.value !== "");
+  }
+  getSubfieldValues(tag, code, indicators) {
+    return this.getSubfields(tag, code, indicators).map(({ value }) => value);
+  }
+  getFirstSubfieldValue(tag, code, indicators) {
+    return this.getSubfieldValues(tag, code, indicators)[0];
+  }
+  toJSON() {
+    return {
+      format: this.format,
+      leader: this.leader,
+      fields: this.fields.map((field) => field.toJSON())
+    };
+  }
+  toString() {
+    return this.fields.map((field) => field.toString()).join("\n");
+  }
+};
+
+// src/marc-record/namespace.ts
+var marcXmlNamespaces = [
+  // The original MARC 21 XML schema (2002)
+  "http://www.loc.gov/MARC21/slim",
+  // Version 1 of the ISO 25577 MarcXchange schema (2007) is for all practical purposes
+  // the same schema as the original MARC 21 XML schema, but weakens restrictions to support
+  // other dialects than MARC 21 (not excluding the most esoteric ones).
+  "info:lc/xmlns/marcxchange-v1",
+  // Version 2 of MarcXchange adds support of embedded data, one of the many
+  // advanced XML features that a poor developer hopes not to encounter in the wild.
+  // Also weakens restrictions even further so that even a completely empty record is valid.
+  "info:lc/xmlns/marcxchange-v2"
+];
+function detectNamespace(input) {
+  for (const possibleNamespace of marcXmlNamespaces) {
+    if (input.indexOf(possibleNamespace) !== -1) {
+      return possibleNamespace;
+    }
+  }
+  return "";
+}
+
+// src/marc-record/parseMarcXml.ts
+function parseMarcXml(input, options = {}) {
+  const namespace = options.namespace ?? detectNamespace(input);
+  const xmlRecord = parseXml(input, {
+    namespaces: {
+      marc: namespace
+    }
+  });
+  const processControlField = options.processControlField ?? ((field) => field);
+  const processDataField = options.processDataField ?? ((field) => field);
+  return xmlRecord.elements("//marc:record").map((marcRecord) => {
+    const leader = marcRecord.text("marc:leader") ?? "";
+    const fields = marcRecord.elements("marc:controlfield | marc:datafield").reduce((fields2, field) => {
+      const tag = field.attr("tag");
+      if (!tag)
+        return fields2;
+      if (field.element?.localName === "controlfield") {
+        const newField = processControlField(
+          new ControlField(tag, field.text() ?? "")
+        );
+        return newField ? [...fields2, newField] : fields2;
+      } else {
+        const subfields = field.elements("marc:subfield").reduce((subfields2, subfield) => {
+          const code = subfield.attr("code");
+          return code ? [...subfields2, new Subfield(code, subfield.text() ?? "")] : subfields2;
+        }, []);
+        const newField = processDataField(
+          new DataField(
+            tag,
+            field.attr("ind1") ?? void 0,
+            field.attr("ind2") ?? void 0,
+            subfields
+          )
+        );
+        return newField ? [...fields2, newField] : fields2;
+      }
+    }, []);
+    return new MarcRecord({ leader, fields, format: options.format });
+  });
+}
+
+export { ControlField, DataField, MarcRecord, Subfield, XmlElement, createControlField, createDataField, parseMarcXml, parseXml };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@biblioteksentralen/marc",
+  "version": "0.0.1",
+  "private": false,
+  "description": "MARC record parser and serializer",
+  "author": "Biblioteksentralen",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "dist/**/*.{js,mjs,d.ts}"
+  ],
+  "dependencies": {
+    "@xmldom/xmldom": "^0.8.10",
+    "ajv": "^8.12.0",
+    "ts-log": "^2.2.5",
+    "xpath": "^0.0.32",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^18.19.31",
+    "@vitest/coverage-v8": "^1.5.0",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "vitest": "^1.5.0",
+    "@dataplattform/eslint-config": "1.0.0"
+  },
+  "scripts": {
+    "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
+    "build": "tsup src/index.ts --format cjs,esm --dts --treeshake",
+    "test": "vitest run --poolOptions.threads.singleThread --reporter=verbose --coverage",
+    "test:watch": "vitest",
+    "clean": "rimraf dist",
+    "lint": "eslint ."
+  }
+}