@biblioteksentralen/marc 0.0.2 → 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.cjs

@@ -248,73 +248,79 @@ 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 = xmlUtils.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()
@@ -331,11 +337,76 @@ var marcRecordZodSchema = zod.z.object({
   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] },
+  {}
+);
+
 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

@@ -1,3 +1,4 @@
+import { XmlElement } from '@biblioteksentralen/xml-utils';
 import { z } from 'zod';
 
 type SerializedMarcField = SerializedDataField | SerializedControlField;
@@ -82,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 {
@@ -99,8 +99,18 @@ interface MarcXmlOptions {
      * 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, options?: MarcXmlOptions): MarcRecord[];
+declare function parseMarcXml(input: string | XmlElement, options?: MarcXmlOptions): Promise<MarcRecord[]>;
 
 declare const marcRecordZodSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -177,4 +187,13 @@ declare const marcRecordZodSchema: z.ZodObject<{
     format?: string | undefined;
 }>;
 
-export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml };
+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,3 +1,4 @@
+import { XmlElement } from '@biblioteksentralen/xml-utils';
 import { z } from 'zod';
 
 type SerializedMarcField = SerializedDataField | SerializedControlField;
@@ -82,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 {
@@ -99,8 +99,18 @@ interface MarcXmlOptions {
      * 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, options?: MarcXmlOptions): MarcRecord[];
+declare function parseMarcXml(input: string | XmlElement, options?: MarcXmlOptions): Promise<MarcRecord[]>;
 
 declare const marcRecordZodSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -177,4 +187,13 @@ declare const marcRecordZodSchema: z.ZodObject<{
     format?: string | undefined;
 }>;
 
-export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml };
+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.js

@@ -1,4 +1,4 @@
-import { parseXml } from '@biblioteksentralen/xml-utils';
+import { parseXml, createXmlElement, serializeXml } from '@biblioteksentralen/xml-utils';
 import { Ajv } from 'ajv';
 import { z } from 'zod';
 
@@ -246,73 +246,79 @@ 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()
@@ -329,4 +335,66 @@ var marcRecordZodSchema = z.object({
   fields: z.array(z.union([controlFieldSchema, dataFieldSchema]))
 });
 
-export { ControlField, DataField, MarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml };
+// 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] },
+  {}
+);
+
+export { ControlField, DataField, MarcParseError, MarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml, serializeLineMarc, serializeMarcXml };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biblioteksentralen/marc",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "description": "MARC record parser and serializer",
@@ -37,7 +37,7 @@
     "@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"
   },