@biblioteksentralen/marc 0.0.1 → 0.0.3

package/README.md

@@ -2,14 +2,14 @@
 
 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>
+The JSON serialization is compatible with the schema defined by <https://www.npmjs.com/package/@natlibfi/marc-record>
 
 ## Usage
 
-### Parsing XML
+### Parsing and serializing XML
 
 ```ts
-import { parseMarcXml } from "@biblioteksentralen/marc";
+import { parseMarcXml, serializeMarcXml } from "@biblioteksentralen/marc";
 
 const xmlRecord = `
 <record xmlns="http://www.loc.gov/MARC21/slim">
@@ -38,9 +38,32 @@ const title = record
   .getSubfieldValues("245", /a|b|n|p/)
   .join(" ")
   ?.trim();
+
+const xml = serializeMarcXml(record);
+```
+
+### Serializing Line MARC
+
+```ts
+import {
+  createControlField,
+  createDataField,
+  createSubfield,
+  serializeLineMarc
+} from "@biblioteksentralen/marc";
+
+const record = new MarcRecord({
+  leader: "...",
+  fields: [
+    createControlField(...),
+    createDataField(...),
+  ]
+});
+
+const lineMarc = serializeLineMarc(record);
 ```
 
-### Serializing / deserializing
+### Serializing and deserializing as JSON
 
 The MarcRecord class can be JSON serialized:
 

package/dist/{index.mjs → index.cjs}

@@ -1,103 +1,10 @@
-import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-import xpath from 'xpath';
-import Ajv from 'ajv';
+'use strict';
 
-// src/xml-element/XmlElement.ts
+var xmlUtils = require('@biblioteksentralen/xml-utils');
+var ajv = require('ajv');
+var zod = require('zod');
 
-// 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/parseMarcXml.ts
 
 // src/marc-record/MarcField.ts
 var Subfield = class {
@@ -272,6 +179,7 @@ function createMarcSchema({
 }
 
 // src/marc-record/MarcRecord.ts
+var validator = new ajv.Ajv().compile(createMarcSchema());
 var ValidationFailed = class extends Error {
   constructor(errors) {
     super("MarcRecord validation failed");
@@ -304,9 +212,6 @@ var MarcRecord = class _MarcRecord {
     });
   }
   static validateJSON(data) {
-    const schema = createMarcSchema();
-    const ajv = new Ajv();
-    const validator = ajv.compile(schema);
     if (validator(data)) {
       return data;
     }
@@ -343,72 +248,165 @@ var MarcRecord = class _MarcRecord {
       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;
-    }
+// src/marc-record/MarcParseError.ts
+var MarcParseError = class extends Error {
+  constructor(message, record) {
+    super(message);
+    this.record = record;
   }
-  return "";
-}
+};
 
 // src/marc-record/parseMarcXml.ts
-function parseMarcXml(input, options = {}) {
-  const namespace = options.namespace ?? detectNamespace(input);
-  const xmlRecord = parseXml(input, {
-    namespaces: {
-      marc: namespace
-    }
-  });
+async function parseMarcXml(input, options = {}) {
+  const xmlRecord = typeof input === "string" ? await xmlUtils.parseXml(input) : input;
   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 { requireFields = true } = options;
+  const records = getRecords(xmlRecord);
+  return records.map((marcRecord) => {
+    const parseError = (message) => new MarcParseError(message, xmlUtils.serializeXml(marcRecord));
+    const leader = marcRecord.text("leader");
+    if (!leader) {
+      throw parseError("MARC record is missing leader");
+    }
+    const fields = marcRecord.children(/controlfield|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() ?? "")
-        );
+      if (!tag) return fields2;
+      if (field.name === "controlfield") {
+        const value = field.text();
+        if (!value && options.strict) {
+          throw parseError("MARC record control fields cannot be empty");
+        }
+        const newField = value ? processControlField(new ControlField(tag, value)) : void 0;
         return newField ? [...fields2, newField] : fields2;
       } else {
-        const subfields = field.elements("marc:subfield").reduce((subfields2, subfield) => {
+        const subfields = field.children("subfield").reduce((subfields2, subfield) => {
           const code = subfield.attr("code");
-          return code ? [...subfields2, new Subfield(code, subfield.text() ?? "")] : subfields2;
+          const value = subfield.text();
+          return code && value ? [...subfields2, new Subfield(code, value)] : subfields2;
         }, []);
-        const newField = processDataField(
-          new DataField(
-            tag,
-            field.attr("ind1") ?? void 0,
-            field.attr("ind2") ?? void 0,
-            subfields
-          )
-        );
+        const ind1 = field.attr("ind1");
+        const ind2 = field.attr("ind2");
+        if (options.strict && (ind1 === void 0 || ind2 === void 0)) {
+          throw parseError("MARC record data fields must have indicators");
+        }
+        if (subfields.length === 0 && options.strict) {
+          throw parseError(
+            "MARC record data fields must have at least one subfield"
+          );
+        }
+        const newField = subfields.length ? processDataField(
+          new DataField(tag, ind1 ?? " ", ind2 ?? " ", subfields)
+        ) : void 0;
         return newField ? [...fields2, newField] : fields2;
       }
     }, []);
+    if (fields.length === 0 && requireFields) {
+      throw parseError("MARC record must have at least one field");
+    }
     return new MarcRecord({ leader, fields, format: options.format });
   });
 }
+function getRecords(node) {
+  switch (node.name) {
+    case "record":
+      return [node];
+    case "collection":
+    // MarcXchange
+    case "metadata":
+      return node.children("record");
+    default:
+      return [];
+  }
+}
+var controlFieldSchema = zod.z.object({
+  tag: zod.z.string().length(3, "MARC tag must be three characters long"),
+  value: zod.z.string()
+});
+var dataFieldSchema = zod.z.object({
+  tag: zod.z.string().length(3, "MARC tag must be three characters long"),
+  ind1: zod.z.string().length(1, "indicator 1 must be one character long").optional(),
+  ind2: zod.z.string().length(1, "indicator 2 must be one character long").optional(),
+  subfields: zod.z.array(zod.z.object({ code: zod.z.string(), value: zod.z.string() }))
+});
+var marcRecordZodSchema = zod.z.object({
+  format: zod.z.string().optional(),
+  leader: zod.z.string(),
+  fields: zod.z.array(zod.z.union([controlFieldSchema, dataFieldSchema]))
+});
+
+// src/marc-record/serializeLineMarc.ts
+function serializeLineMarc(input) {
+  const leader = serializer.leader(input.leader);
+  const control = input.getControlFields().map(serializer.controlfield).join("");
+  const data = input.getDataFields().map(serializer.datafield).join("");
+  return `${leader}${control}${data}^
+`;
+}
+var serializer = {
+  leader: (leader) => `*LDR ${leader}
+`,
+  controlfield: (field) => `*${field.tag}${field.value}
+`,
+  datafield: (field) => {
+    const ind1 = field.ind1 ?? " ";
+    const ind2 = field.ind2 ?? " ";
+    const subfields = field.subfields.map(
+      (subfield) => `$${subfield.code}${escapeSubfieldValue(subfield.value)}`
+    ).join("");
+    return `*${field.tag}${ind1}${ind2}${subfields}
+`;
+  }
+};
+var escapeSubfieldValue = (value) => {
+  return value.replace(/\$/g, "$$");
+};
+function serializeMarcXml(input, pretty = false) {
+  const fields = [
+    xmlUtils.createXmlElement("leader", { text: input.leader }),
+    ...input.getControlFields().map(
+      (field) => xmlUtils.createXmlElement("controlfield", {
+        attributes: { tag: field.tag },
+        text: field.value
+      })
+    ),
+    ...input.getDataFields().map(
+      (field) => xmlUtils.createXmlElement("datafield", {
+        attributes: withoutEmptyValues({
+          tag: field.tag,
+          ind1: field.ind1,
+          ind2: field.ind2
+        }),
+        children: field.subfields.map(
+          (subfield) => xmlUtils.createXmlElement("subfield", {
+            attributes: { code: subfield.code },
+            text: subfield.value
+          })
+        )
+      })
+    )
+  ];
+  const recordNode = xmlUtils.createXmlElement("record", {
+    attributes: { xmlns: "http://www.loc.gov/MARC21/slim" },
+    children: fields
+  });
+  return xmlUtils.serializeXml(recordNode, pretty);
+}
+var withoutEmptyValues = (obj) => Object.keys(obj).reduce(
+  (acc, key) => obj[key] === void 0 ? { ...acc } : { ...acc, [key]: obj[key] },
+  {}
+);
 
-export { ControlField, DataField, MarcRecord, Subfield, XmlElement, createControlField, createDataField, parseMarcXml, parseXml };
+exports.ControlField = ControlField;
+exports.DataField = DataField;
+exports.MarcParseError = MarcParseError;
+exports.MarcRecord = MarcRecord;
+exports.Subfield = Subfield;
+exports.createControlField = createControlField;
+exports.createDataField = createDataField;
+exports.marcRecordZodSchema = marcRecordZodSchema;
+exports.parseMarcXml = parseMarcXml;
+exports.serializeLineMarc = serializeLineMarc;
+exports.serializeMarcXml = serializeMarcXml;

package/dist/index.d.cts

@@ -0,0 +1,199 @@
+import { XmlElement } from '@biblioteksentralen/xml-utils';
+import { z } from 'zod';
+
+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 {
+    /**
+     * Identifies the MARC format (examples: "MARC 21", "UNIMARC", "danMARC2", ...).
+     */
+    format?: string;
+    /**
+     * Corresponds to ISO 2709 record label, 24 bytes
+     */
+    leader: string;
+    /**
+     * List of control fields and data fields.
+     */
+    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;
+}
+
+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;
+    /**
+     * Whether to require at least one field to be present. Defaults to true.
+     */
+    requireFields?: boolean;
+    /**
+     * If set to true, the parser throws an error if a record is missing indicators or have empty
+     * fields or subfields. If set to false, it will set default values for missing indicators and
+     * skip empty fields and subfields. Defaults to false.
+     */
+    strict?: boolean;
+}
+declare function parseMarcXml(input: string | XmlElement, options?: MarcXmlOptions): Promise<MarcRecord[]>;
+
+declare const marcRecordZodSchema: z.ZodObject<{
+    format: z.ZodOptional<z.ZodString>;
+    leader: z.ZodString;
+    fields: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        tag: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tag: string;
+        value: string;
+    }, {
+        tag: string;
+        value: string;
+    }>, z.ZodObject<{
+        tag: z.ZodString;
+        ind1: z.ZodOptional<z.ZodString>;
+        ind2: z.ZodOptional<z.ZodString>;
+        subfields: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            code: string;
+        }, {
+            value: string;
+            code: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    }, {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    fields: ({
+        tag: string;
+        value: string;
+    } | {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    })[];
+    leader: string;
+    format?: string | undefined;
+}, {
+    fields: ({
+        tag: string;
+        value: string;
+    } | {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    })[];
+    leader: string;
+    format?: string | undefined;
+}>;
+
+declare function serializeLineMarc(input: MarcRecord): string;
+
+declare function serializeMarcXml(input: MarcRecord, pretty?: boolean): string;
+
+declare class MarcParseError extends Error {
+    readonly record: string;
+    constructor(message: string, record: string);
+}
+
+export { ControlField, DataField, type MarcField, MarcParseError, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcField, type SerializedMarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml, serializeLineMarc, serializeMarcXml };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import xpath from 'xpath';
-import { Logger } from 'ts-log';
+import { XmlElement } from '@biblioteksentralen/xml-utils';
+import { z } from 'zod';
 
 type SerializedMarcField = SerializedDataField | SerializedControlField;
 interface SerializedControlField {
@@ -51,8 +51,17 @@ type Indicators = {
     ind2?: string;
 };
 interface SerializedMarcRecord {
+    /**
+     * Identifies the MARC format (examples: "MARC 21", "UNIMARC", "danMARC2", ...).
+     */
     format?: string;
+    /**
+     * Corresponds to ISO 2709 record label, 24 bytes
+     */
     leader: string;
+    /**
+     * List of control fields and data fields.
+     */
     fields: SerializedMarcField[];
 }
 declare class MarcRecord {
@@ -74,7 +83,6 @@ declare class MarcRecord {
     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 {
@@ -91,53 +99,101 @@ interface MarcXmlOptions {
      * 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.
+     * Whether to require at least one field to be present. Defaults to true.
      */
-    getNamespaces(): NamespaceMap;
+    requireFields?: boolean;
     /**
-     * Find anything (nodes, text, etc.) by xpath.
-     * @param {string} query - XPath query.
+     * If set to true, the parser throws an error if a record is missing indicators or have empty
+     * fields or subfields. If set to false, it will set default values for missing indicators and
+     * skip empty fields and subfields. Defaults to false.
      */
-    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;
+    strict?: boolean;
+}
+declare function parseMarcXml(input: string | XmlElement, options?: MarcXmlOptions): Promise<MarcRecord[]>;
+
+declare const marcRecordZodSchema: z.ZodObject<{
+    format: z.ZodOptional<z.ZodString>;
+    leader: z.ZodString;
+    fields: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        tag: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tag: string;
+        value: string;
+    }, {
+        tag: string;
+        value: string;
+    }>, z.ZodObject<{
+        tag: z.ZodString;
+        ind1: z.ZodOptional<z.ZodString>;
+        ind2: z.ZodOptional<z.ZodString>;
+        subfields: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            code: string;
+        }, {
+            value: string;
+            code: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    }, {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    fields: ({
+        tag: string;
+        value: string;
+    } | {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    })[];
+    leader: string;
+    format?: string | undefined;
+}, {
+    fields: ({
+        tag: string;
+        value: string;
+    } | {
+        tag: string;
+        subfields: {
+            value: string;
+            code: string;
+        }[];
+        ind1?: string | undefined;
+        ind2?: string | undefined;
+    })[];
+    leader: string;
+    format?: string | undefined;
+}>;
+
+declare function serializeLineMarc(input: MarcRecord): string;
+
+declare function serializeMarcXml(input: MarcRecord, pretty?: boolean): string;
+
+declare class MarcParseError extends Error {
+    readonly record: string;
+    constructor(message: string, record: string);
 }
 
-export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, XmlElement, createControlField, createDataField, parseMarcXml, parseXml };
+export { ControlField, DataField, type MarcField, MarcParseError, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcField, type SerializedMarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml, serializeLineMarc, serializeMarcXml };

package/dist/index.js

@@ -1,110 +1,8 @@
-'use strict';
+import { parseXml, createXmlElement, serializeXml } from '@biblioteksentralen/xml-utils';
+import { Ajv } from 'ajv';
+import { z } from 'zod';
 
-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/parseMarcXml.ts
 
 // src/marc-record/MarcField.ts
 var Subfield = class {
@@ -279,6 +177,7 @@ function createMarcSchema({
 }
 
 // src/marc-record/MarcRecord.ts
+var validator = new Ajv().compile(createMarcSchema());
 var ValidationFailed = class extends Error {
   constructor(errors) {
     super("MarcRecord validation failed");
@@ -311,9 +210,6 @@ var MarcRecord = class _MarcRecord {
     });
   }
   static validateJSON(data) {
-    const schema = createMarcSchema();
-    const ajv = new Ajv__default.default();
-    const validator = ajv.compile(schema);
     if (validator(data)) {
       return data;
     }
@@ -350,80 +246,155 @@ var MarcRecord = class _MarcRecord {
       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;
-    }
+// src/marc-record/MarcParseError.ts
+var MarcParseError = class extends Error {
+  constructor(message, record) {
+    super(message);
+    this.record = record;
   }
-  return "";
-}
+};
 
 // src/marc-record/parseMarcXml.ts
-function parseMarcXml(input, options = {}) {
-  const namespace = options.namespace ?? detectNamespace(input);
-  const xmlRecord = parseXml(input, {
-    namespaces: {
-      marc: namespace
-    }
-  });
+async function parseMarcXml(input, options = {}) {
+  const xmlRecord = typeof input === "string" ? await parseXml(input) : input;
   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 { requireFields = true } = options;
+  const records = getRecords(xmlRecord);
+  return records.map((marcRecord) => {
+    const parseError = (message) => new MarcParseError(message, serializeXml(marcRecord));
+    const leader = marcRecord.text("leader");
+    if (!leader) {
+      throw parseError("MARC record is missing leader");
+    }
+    const fields = marcRecord.children(/controlfield|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() ?? "")
-        );
+      if (!tag) return fields2;
+      if (field.name === "controlfield") {
+        const value = field.text();
+        if (!value && options.strict) {
+          throw parseError("MARC record control fields cannot be empty");
+        }
+        const newField = value ? processControlField(new ControlField(tag, value)) : void 0;
         return newField ? [...fields2, newField] : fields2;
       } else {
-        const subfields = field.elements("marc:subfield").reduce((subfields2, subfield) => {
+        const subfields = field.children("subfield").reduce((subfields2, subfield) => {
           const code = subfield.attr("code");
-          return code ? [...subfields2, new Subfield(code, subfield.text() ?? "")] : subfields2;
+          const value = subfield.text();
+          return code && value ? [...subfields2, new Subfield(code, value)] : subfields2;
         }, []);
-        const newField = processDataField(
-          new DataField(
-            tag,
-            field.attr("ind1") ?? void 0,
-            field.attr("ind2") ?? void 0,
-            subfields
-          )
-        );
+        const ind1 = field.attr("ind1");
+        const ind2 = field.attr("ind2");
+        if (options.strict && (ind1 === void 0 || ind2 === void 0)) {
+          throw parseError("MARC record data fields must have indicators");
+        }
+        if (subfields.length === 0 && options.strict) {
+          throw parseError(
+            "MARC record data fields must have at least one subfield"
+          );
+        }
+        const newField = subfields.length ? processDataField(
+          new DataField(tag, ind1 ?? " ", ind2 ?? " ", subfields)
+        ) : void 0;
         return newField ? [...fields2, newField] : fields2;
       }
     }, []);
+    if (fields.length === 0 && requireFields) {
+      throw parseError("MARC record must have at least one field");
+    }
     return new MarcRecord({ leader, fields, format: options.format });
   });
 }
+function getRecords(node) {
+  switch (node.name) {
+    case "record":
+      return [node];
+    case "collection":
+    // MarcXchange
+    case "metadata":
+      return node.children("record");
+    default:
+      return [];
+  }
+}
+var controlFieldSchema = z.object({
+  tag: z.string().length(3, "MARC tag must be three characters long"),
+  value: z.string()
+});
+var dataFieldSchema = z.object({
+  tag: z.string().length(3, "MARC tag must be three characters long"),
+  ind1: z.string().length(1, "indicator 1 must be one character long").optional(),
+  ind2: z.string().length(1, "indicator 2 must be one character long").optional(),
+  subfields: z.array(z.object({ code: z.string(), value: z.string() }))
+});
+var marcRecordZodSchema = z.object({
+  format: z.string().optional(),
+  leader: z.string(),
+  fields: z.array(z.union([controlFieldSchema, dataFieldSchema]))
+});
+
+// src/marc-record/serializeLineMarc.ts
+function serializeLineMarc(input) {
+  const leader = serializer.leader(input.leader);
+  const control = input.getControlFields().map(serializer.controlfield).join("");
+  const data = input.getDataFields().map(serializer.datafield).join("");
+  return `${leader}${control}${data}^
+`;
+}
+var serializer = {
+  leader: (leader) => `*LDR ${leader}
+`,
+  controlfield: (field) => `*${field.tag}${field.value}
+`,
+  datafield: (field) => {
+    const ind1 = field.ind1 ?? " ";
+    const ind2 = field.ind2 ?? " ";
+    const subfields = field.subfields.map(
+      (subfield) => `$${subfield.code}${escapeSubfieldValue(subfield.value)}`
+    ).join("");
+    return `*${field.tag}${ind1}${ind2}${subfields}
+`;
+  }
+};
+var escapeSubfieldValue = (value) => {
+  return value.replace(/\$/g, "$$");
+};
+function serializeMarcXml(input, pretty = false) {
+  const fields = [
+    createXmlElement("leader", { text: input.leader }),
+    ...input.getControlFields().map(
+      (field) => createXmlElement("controlfield", {
+        attributes: { tag: field.tag },
+        text: field.value
+      })
+    ),
+    ...input.getDataFields().map(
+      (field) => createXmlElement("datafield", {
+        attributes: withoutEmptyValues({
+          tag: field.tag,
+          ind1: field.ind1,
+          ind2: field.ind2
+        }),
+        children: field.subfields.map(
+          (subfield) => createXmlElement("subfield", {
+            attributes: { code: subfield.code },
+            text: subfield.value
+          })
+        )
+      })
+    )
+  ];
+  const recordNode = createXmlElement("record", {
+    attributes: { xmlns: "http://www.loc.gov/MARC21/slim" },
+    children: fields
+  });
+  return serializeXml(recordNode, pretty);
+}
+var withoutEmptyValues = (obj) => Object.keys(obj).reduce(
+  (acc, key) => obj[key] === void 0 ? { ...acc } : { ...acc, [key]: obj[key] },
+  {}
+);
 
-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;
+export { ControlField, DataField, MarcParseError, MarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml, serializeLineMarc, serializeMarcXml };

package/package.json

@@ -1,38 +1,43 @@
 {
   "name": "@biblioteksentralen/marc",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
+  "type": "module",
   "description": "MARC record parser and serializer",
   "author": "Biblioteksentralen",
   "license": "MIT",
-  "main": "dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+    "import": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
     "README.md",
     "LICENSE",
-    "dist/**/*.{js,mjs,d.ts}"
+    "dist/**/*.{js,cjs,mjs,ts,d.ts,d.cts}"
   ],
   "dependencies": {
-    "@xmldom/xmldom": "^0.8.10",
-    "ajv": "^8.12.0",
+    "ajv": "^8.17.1",
     "ts-log": "^2.2.5",
-    "xpath": "^0.0.32",
-    "zod": "^3.22.4"
+    "zod": "^3.23.8",
+    "@biblioteksentralen/xml-utils": "^0.0.1"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.4",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^18.19.31",
+    "@types/node": "^20.14.14",
     "@vitest/coverage-v8": "^1.5.0",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.2",
-    "typescript": "^5.3.3",
+    "typescript": "^5.6.2",
     "vitest": "^1.5.0",
     "@dataplattform/eslint-config": "1.0.0"
   },
@@ -42,6 +47,7 @@
     "test": "vitest run --poolOptions.threads.singleThread --reporter=verbose --coverage",
     "test:watch": "vitest",
     "clean": "rimraf dist",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "lint:package": "attw --pack"
   }
 }