@biblioteksentralen/marc 0.0.1 → 0.0.2

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;
     }
@@ -373,7 +278,7 @@ function detectNamespace(input) {
 // src/marc-record/parseMarcXml.ts
 function parseMarcXml(input, options = {}) {
   const namespace = options.namespace ?? detectNamespace(input);
-  const xmlRecord = parseXml(input, {
+  const xmlRecord = xmlUtils.parseXml(input, {
     namespaces: {
       marc: namespace
     }
@@ -410,5 +315,27 @@ function parseMarcXml(input, options = {}) {
     return new MarcRecord({ leader, fields, format: options.format });
   });
 }
+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]))
+});
 
-export { ControlField, DataField, MarcRecord, Subfield, XmlElement, createControlField, createDataField, parseMarcXml, parseXml };
+exports.ControlField = ControlField;
+exports.DataField = DataField;
+exports.MarcRecord = MarcRecord;
+exports.Subfield = Subfield;
+exports.createControlField = createControlField;
+exports.createDataField = createDataField;
+exports.marcRecordZodSchema = marcRecordZodSchema;
+exports.parseMarcXml = parseMarcXml;

package/dist/index.d.cts

@@ -0,0 +1,180 @@
+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;
+    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[];
+
+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;
+}>;
+
+export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml };

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import xpath from 'xpath';
-import { Logger } from 'ts-log';
+import { z } from 'zod';
 
 type SerializedMarcField = SerializedDataField | SerializedControlField;
 interface SerializedControlField {
@@ -51,8 +50,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 {
@@ -94,50 +102,79 @@ interface MarcXmlOptions {
 }
 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;
-}
+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;
+}>;
 
-export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, XmlElement, createControlField, createDataField, parseMarcXml, parseXml };
+export { ControlField, DataField, type MarcField, MarcRecord, type SerializedControlField, type SerializedDataField, type SerializedMarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml };

package/dist/index.js

@@ -1,110 +1,8 @@
-'use strict';
+import { parseXml } 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;
     }
@@ -417,13 +313,20 @@ function parseMarcXml(input, options = {}) {
     return new MarcRecord({ leader, fields, format: options.format });
   });
 }
+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]))
+});
 
-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, MarcRecord, Subfield, createControlField, createDataField, marcRecordZodSchema, parseMarcXml };

package/package.json

@@ -1,34 +1,39 @@
 {
   "name": "@biblioteksentralen/marc",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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",
@@ -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"
   }
 }