@natlibfi/marc-record-validators-melinda 12.1.0-alpha.1 → 13.0.0

package/src/punctuation2.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 /*
 * punctuation.js -- try and fix a marc field punctuation
 *
@@ -10,13 +11,15 @@
 *          (They are jumped over when looking for next (non-controlfield subfield)
 */
 import {validateSingleField} from './ending-punctuation.js';
-import {tagToDataProvenanceSubfieldCode} from './merge-fields/dataProvenance.js';
+import {tagToDataProvenanceSubfieldCode} from './dataProvenanceUtils.js';
 import {fieldGetUnambiguousTag} from './subfield6Utils.js';
-//import createDebugLogger from 'debug';
-import {fieldToString, isControlSubfieldCode, nvdebug} from './utils.js';
+import createDebugLogger from 'debug';
+import {fieldToString, isContentSubfieldCode, nvdebug} from './utils.js';
 import clone from 'clone';
 
-//const debug = createDebugLogger('debug/punctuation2');
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:punctuation2');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 const descriptionString = 'Remove invalid and add valid punctuation to data fields';
 export default function () {
@@ -26,14 +29,14 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug(`${descriptionString}: fixer`);
+    nvdebug(`${descriptionString}: fixer`, debugDev);
     const res = {message: [], fix: [], valid: true};
     record.fields.forEach(f => fieldFixPunctuation(f));
     return res;
   }
 
   function validate(record) {
-    nvdebug(`${descriptionString}: validate`);
+    nvdebug(`${descriptionString}: validate`, debugDev);
 
     const fieldsNeedingModification = record.fields.filter(f => fieldNeedsModification(f, true));
 
@@ -57,7 +60,7 @@ function isIrrelevantSubfield(subfield, tag) {
   if (subfield.code === dataProvenanceSubfieldCode) {
     return true;
   }
-  return isControlSubfieldCode(subfield.code); // Currently this contains other stuff as well ($3, $4, $7, $9...)
+  return !isContentSubfieldCode(subfield.code); // Currently this contains other stuff as well ($3, $4, $7, $9...)
 }
 
 
@@ -123,16 +126,16 @@ const X00RemoveDotAfterBracket = {'code': 'cq', 'context': /\)\.$/u, 'remove': /
 // 390, 800, 810, 830...
 const cleanPuncBeforeLanguage = {'code': 'atvxyz', 'followedBy': 'l', 'context': puncIsProbablyPunc, 'remove': / *[.,:;]$/u};
 
-const addX00aComma = {'add': ',', 'code': 'abcqej', 'followedBy': 'cdeg', 'context': doesNotEndInPunc, 'contextRHS': allowsPuncRHS};
+const addX00aComma = {'add': ',', 'code': 'abcqejt', 'followedBy': 'cdegnr', 'context': doesNotEndInPunc, 'contextRHS': allowsPuncRHS};
 const addX00dComma = {'name': 'X00$d ending in "-" does not get comma', 'add': ',', 'code': 'd', 'followedBy': 'cdeg', 'context': /[^-,.!]$/u, 'contextRHS': allowsPuncRHS};
 const addX00aComma2 = {'add': ',', 'code': 'abcdej', 'followedBy': 'cdeg', 'context': /(?:[A-Z]|Å|Ä|Ö)\.$/u, 'contextRHS': allowsPuncRHS};
 const addX00Dot = {'add': '.', 'code': 'abcdetv', 'followedBy': 'fklptu', 'context': needsPuncAfterAlphanumeric};
 const addEntryFieldFinalDot = {'name': 'X00 final dot', 'add': '.', 'code': 'abcdefghijklmnopqrstuvwxyz', 'followedBy': '#', 'context': /[^.)!?-]$/u};
 
 
-const addX10iColon = {name: 'Punctuate relationship information', add: ':', code: 'i', context: defaultNeedsPuncAfter2};
+const addXX0iColon = {name: 'Punctuate relationship information', add: ':', code: 'i', context: defaultNeedsPuncAfter2}; // Not explicitly checking it, but this should always be followed by 'a' or 't'
 const addX10bDot = {'name': 'Add X10 pre-$b dot', 'add': '.', 'code': 'ab', 'followedBy': 'b', 'context': defaultNeedsPuncAfter2};
-const addX10eComma = {'add': ',', 'code': 'abe', 'followedBy': 'e', 'context': defaultNeedsPuncAfter2};
+const addX10Comma = {'add': ',', 'code': 'abet', 'followedBy': 'en', 'context': defaultNeedsPuncAfter2};
 const addX10Dot = {'name': 'Add X10 final dot', 'add': '.', 'code': 'abet', 'followedBy': 'tu#', 'context': needsPuncAfterAlphanumeric};
 const addColonToRelationshipInformation = {'name': 'Add \':\' to 7X0 $i relationship info', 'add': ':', 'code': 'i', 'context': defaultNeedsPuncAfter2};
 
@@ -223,11 +226,11 @@ const cleanCrappyPunctuationRules = {
   '946': crappy24X
 };
 
-const cleanLegalX00Comma = {'code': 'abcde', 'followedBy': 'cdegj', 'context': /.,$/u, 'remove': /,$/u};
+const cleanLegalX00Comma = {'code': 'abcdetn', 'followedBy': 'cdegjnr', 'context': /.,$/u, 'remove': /,$/u};
 // Accept upper case letters in X00$b, since they are probably Roman numerals.
 const cleanLegalX00bDot = {'code': 'b', 'followedBy': 't#', context: /^[IVXLCDM]+\.$/u, 'remove': /\.$/u};
 const cleanLegalX00iColon = {'code': 'i', 'followedBy': 'a', 'remove': / *:$/u}; // NB! context is not needed
-const cleanLegalX00Dot = {'code': 'abcdetvl', 'followedBy': 'tu#', 'context': /(?:[a-z0-9)]|å|ä|ö)\.$/u, 'remove': /\.$/u};
+const cleanLegalX00Dot = {'code': 'abcdetkvl', 'followedBy': 'tklu#', 'context': /(?:[a-z0-9)]|å|ä|ö)\.$/u, 'remove': /\.$/u};
 const cleanDotBeforeLanguageSubfieldL = {'name': 'pre-language-$l dot', 'followedBy': 'l', 'context': /.\.$/u, 'remove': /\.$/u};
 
 const legalEntryField = [cleanDotBeforeLanguageSubfieldL];
@@ -313,8 +316,8 @@ const cleanValidPunctuationRules = {
 const addToAllEntryFields = [addDotBeforeLanguageSubfieldL, addSemicolonBeforeVolumeDesignation, addColonToRelationshipInformation, addEntryFieldFinalDot];
 
 
-const addX00 = [addX00aComma, addX00aComma2, addX00Dot, addX00dComma, ...addToAllEntryFields];
-const addX10 = [addX10iColon, addX10bDot, addX10eComma, addX10Dot, ...addToAllEntryFields];
+const addX00 = [addXX0iColon, addX00aComma, addX00aComma2, addX00Dot, addX00dComma, ...addToAllEntryFields];
+const addX10 = [addXX0iColon, addX10bDot, addX10Comma, addX10Dot, ...addToAllEntryFields];
 const addX11 = [...addToAllEntryFields, addX11Spacecolon];
 const addX30 = [...addToAllEntryFields];
 
@@ -396,19 +399,19 @@ const addPairedPunctuationRules = {
 
 /*
 function debugRule(rule) {
-  //nvdebug('');
-  nvdebug(`NAME ${rule.name ? rule.name : '<unnamed>'}`);
-  nvdebug(`SUBFIELD CODE '${rule.code}' FOLLOWED BY SUBFIELD CODE '${rule.followedBy}'`);
+  //nvdebug('', debugDev);
+  nvdebug(`NAME ${rule.name ? rule.name : '<unnamed>'}`, debugDev);
+  nvdebug(`SUBFIELD CODE '${rule.code}' FOLLOWED BY SUBFIELD CODE '${rule.followedBy}'`, debugDev);
   if ('add' in rule) {
-    nvdebug(`ADD '${rule.add}'`);
+    nvdebug(`ADD '${rule.add}'`, debugDev);
   }
   if ('remove' in rule) {
-    nvdebug(`REMOVE '${rule.remove}'`);
+    nvdebug(`REMOVE '${rule.remove}'`, debugDev);
   }
   if ('context' in rule) {
-    nvdebug(`CONTEXT '${rule.context.toString()}'`);
+    nvdebug(`CONTEXT '${rule.context.toString()}'`, debugDev);
   }
-  //nvdebug('');
+  //nvdebug('', debugDev);
 }
 */
 
@@ -440,19 +443,19 @@ function ruleAppliesToField(rule, field) {
 
 
 function ruleAppliesToCurrentSubfield(rule, subfield) {
-  //nvdebug(`  Apply rule on LHS?`);
+  //nvdebug(`  Apply rule on LHS?`, debugDev);
   if (!ruleAppliesToSubfieldCode(rule.code, subfield.code)) {
-    //nvdebug(`  Reject rule!`);
+    //nvdebug(`  Reject rule!`, debugDev);
     return false;
   }
   if ('context' in rule) {
-    //nvdebug(`  Check '${subfield.value}' versus '${rule.context.toString()}'`);
+    //nvdebug(`  Check '${subfield.value}' versus '${rule.context.toString()}'`, debugDev);
     if (!subfield.value.match(rule.context)) { // njsscan-ignore: regex_injection_dos
-      //nvdebug(`  Reject rule!`);
+      //nvdebug(`  Reject rule!`, debugDev);
       return false;
     }
   }
-  //nvdebug(`  Apply rule!`);
+  //nvdebug(`  Apply rule!`, debugDev);
   return true;
 }
 
@@ -480,23 +483,24 @@ function ruleAppliesToNextSubfield(rule, nextSubfield) {
 
 function checkRule(rule, field, subfield1, subfield2) {
   if (!ruleAppliesToField(rule, field)) {
-    //nvdebug(`FAIL ON WHOLE FIELD: '${fieldToString(field)}`);
+    //nvdebug(`FAIL ON WHOLE FIELD: '${fieldToString(field)}`, debugDev);
     return false;
   }
   //const name = rule.name || 'UNNAMED';
   if (!ruleAppliesToCurrentSubfield(rule, subfield1)) {
-    //nvdebug(`${name}: FAIL ON LHS SUBFIELD: '$${subfield1.code} ${subfield1.value}', SF=${rule.code}`, debug);
+    //nvdebug(`${name}: FAIL ON LHS SUBFIELD: '$${subfield1.code} ${subfield1.value}', SF=${rule.code}`, debugDev);
     return false;
   }
 
   // NB! This is not a perfect solution. We might have $e$0$e where $e$0 punctuation should actually be based on $e$e rules
   if (!ruleAppliesToNextSubfield(rule, subfield2)) {
     //const msg = subfield2 ? `${name}: FAIL ON RHS SUBFIELD '${subfield2.code}' not in [${rule.followedBy}]` : `${name}: FAIL ON RHS FIELD`;
-    //nvdebug(msg, debug);
+    //nvdebug(msg, debugDev);
     return false;
   }
 
-  //nvdebug(`${rule.name ? rule.name : '<unnamed>'}: ACCEPT ${rule.code} (${subfield1.code}), SF2=${rule.followedBy} (${subfield2 ? subfield2.code : '#'})`, debug);
+   
+  //nvdebug(`${rule.name ? rule.name : '<unnamed>'}: ACCEPT ${rule.code} (${subfield1.code}), SF2=${rule.followedBy} (${subfield2 ? subfield2.code : '#'})`, debugDev);
   return true;
 }
 
@@ -513,9 +517,9 @@ function applyPunctuationRules(field, subfield1, subfield2, ruleArray = null, op
     return;
   }
 
-  //nvdebug(`PUNCTUATE ${field.tag}/${tag2} '${subfieldToString(subfield1)}' XXX '${subfield2 ? subfieldToString(subfield2) : '#'} }`);
+  //nvdebug(`PUNCTUATE ${field.tag}/${tag2} '${subfieldToString(subfield1)}' XXX '${subfield2 ? subfieldToString(subfield2) : '#'} }`, debugDev);
 
-  //nvdebug(`OP=${operation} ${tag2}: '${subfield1.code}: ${subfield1.value}' ??? '${subfield2 ? subfield2.code : '#'}'`);
+  //nvdebug(`OP=${operation} ${tag2}: '${subfield1.code}: ${subfield1.value}' ??? '${subfield2 ? subfield2.code : '#'}'`, debugDev);
   const candRules = ruleArray[tag2];
   candRules.every(rule => { // uses "every", not "forEach", so that only one rule is applies to the given subfields
     //debugRule(rule);
@@ -525,20 +529,20 @@ function applyPunctuationRules(field, subfield1, subfield2, ruleArray = null, op
 
     //const originalValue = subfield1.value;
     if (rule.remove && [REMOVE, REMOVE_AND_ADD].includes(operation) && subfield1.value.match(rule.remove)) {
-      //nvdebug(`    PUNC REMOVAL TO BE PERFORMED FOR $${subfield1.code} '${subfield1.value}'`, debug);
+      //nvdebug(`    PUNC REMOVAL TO BE PERFORMED FOR $${subfield1.code} '${subfield1.value}'`, debugDev);
       subfield1.value = subfield1.value.replace(rule.remove, '');
-      //nvdebug(`    PUNC REMOVAL PERFORMED FOR '${subfield1.value}'`);
+      //nvdebug(`    PUNC REMOVAL PERFORMED FOR '${subfield1.value}'`, debugDev);
       return false;
     }
     if (rule.add && [ADD, REMOVE_AND_ADD].includes(operation)) {
       subfield1.value += rule.add;
-      //nvdebug(`    ADDED '${rule.add}' TO FORM '${subfield1.value}' USING RULE ${rule.name}`);
+      //nvdebug(`    ADDED '${rule.add}' TO FORM '${subfield1.value}' USING RULE ${rule.name}`, debugDev);
       return false;
     }
 
     /*
     if (subfield1.value !== originalValue) {
-      nvdebug(` PROCESS PUNC: '‡${subfield1.code} ${originalValue}' => '‡${subfield1.code} ${subfield1.value}'`, debug);
+      nvdebug(` PROCESS PUNC: '‡${subfield1.code} ${originalValue}' => '‡${subfield1.code} ${subfield1.value}'`, debugDev);
     }
     */
 
@@ -552,11 +556,11 @@ function subfieldFixPunctuation(field, subfield1, subfield2) {
 }
 
 function subfieldStripPunctuation(field, subfield1, subfield2) {
-  //nvdebug(`FSP1: '${subfield1.value}'`);
+  //nvdebug(`FSP1: '${subfield1.value}'`, debugDev);
   applyPunctuationRules(field, subfield1, subfield2, cleanValidPunctuationRules, REMOVE);
-  //nvdebug(`FSP2: '${subfield1.value}'`);
+  //nvdebug(`FSP2: '${subfield1.value}'`, debugDev);
   applyPunctuationRules(field, subfield1, subfield2, cleanCrappyPunctuationRules, REMOVE);
-  //nvdebug(`FSP3: '${subfield1.value}'`);
+  //nvdebug(`FSP3: '${subfield1.value}'`, debugDev);
 
 }
 
@@ -578,7 +582,7 @@ export function fieldFixPunctuation(field) {
   if (!field.subfields) {
     return field;
   }
-  //nvdebug(`################### fieldFixPunctuation() TEST ${fieldToString(field)}`);
+  //nvdebug(`################### fieldFixPunctuation() TEST ${fieldToString(field)}`, debugDev);
 
   field.subfields.forEach((sf, i) => {
     // NB! instead of next subfield, we should actually get next *non-control-subfield*!!!

package/src/punctuation2.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './punctuation2.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -19,7 +19,7 @@ generateTests({
     }
   }
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/punctuation2:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/punctuation2:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -29,12 +29,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/reindexSubfield6OccurenceNumbers.js

@@ -7,6 +7,8 @@ import {fieldGetOccurrenceNumberPairs, fieldGetUnambiguousOccurrenceNumber, fiel
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:reindexSubfield6OccurrenceNumbers');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 
 // NB! This validator/fixer has two functionalities:
@@ -20,7 +22,7 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug('Fix SF6 occurrence numbers', debug);
+    nvdebug('Fix SF6 occurrence numbers', debugDev);
     const res = {message: [], fix: [], valid: true};
     //message.fix = [];
 
@@ -36,13 +38,13 @@ export default function () {
   function validate(record) {
     const res = {message: []};
 
-    nvdebug('Validate SF6 occurrence number multiuses', debug);
+    nvdebug('Validate SF6 occurrence number multiuses', debugDev);
     if (recordGetSharedOccurrenceNumbers(record).length) {
       res.message.push(`Multi-use of occurrence number(s) detected`);
     }
 
     // Check max, and check number of different indexes
-    nvdebug('Validate SF6 occurrence number (max vs n instances)', debug);
+    nvdebug('Validate SF6 occurrence number (max vs n instances)', debugDev);
     const max = recordGetMaxSubfield6OccurrenceNumberAsInteger(record);
     const size = recordGetNumberOfUniqueSubfield6OccurrenceNumbers(record);
 
@@ -90,7 +92,7 @@ function recordDisambiguateSharedSubfield6OccurrenceNumbers(record) {
   if (sharedOccurrenceNumberFields.length < 2) {
     return;
   }
-  nvdebug(`Disambiguate occurrence numbers (N=${sharedOccurrenceNumberFields.length}) in...`, debug);
+  nvdebug(`Disambiguate occurrence numbers (N=${sharedOccurrenceNumberFields.length}) in...`, debugDev);
   sharedOccurrenceNumberFields.forEach(field => disambiguateOccurrenceNumber(field));
 
   function disambiguateable(field) {
@@ -98,20 +100,20 @@ function recordDisambiguateSharedSubfield6OccurrenceNumbers(record) {
       return false;
     }
     const occurrenceNumber = fieldGetUnambiguousOccurrenceNumber(field);
-    nvdebug(` Trying to disambiguate ${occurrenceNumber} in '${fieldToString(field)}`);
+    nvdebug(` Trying to disambiguate ${occurrenceNumber} in '${fieldToString(field)}`, debugDev);
     if (occurrenceNumber === undefined) {
       return false;
     }
     const allRelevantFields = getPotentialSharedOccurrenceNumberFields(occurrenceNumber, sharedOccurrenceNumberFields);
     if (allRelevantFields.length < 2) {
-      nvdebug(` Currently only ${allRelevantFields.length} field(s) use occurrence number ${occurrenceNumber}. No action required.`);
+      nvdebug(` Currently only ${allRelevantFields.length} field(s) use occurrence number ${occurrenceNumber}. No action required.`, debugDev);
       return false;
     }
-    nvdebug(` Currently ${allRelevantFields.length} field(s) use occurrence number ${occurrenceNumber}. ACTION REQUIRED!`);
+    nvdebug(` Currently ${allRelevantFields.length} field(s) use occurrence number ${occurrenceNumber}. ACTION REQUIRED!`, debugDev);
     const relevantFieldsWithCurrFieldTag = allRelevantFields.filter(candField => field.tag === candField.tag);
 
     if (relevantFieldsWithCurrFieldTag.length !== 1) {
-      nvdebug(` Number of them using tag ${field.tag} is ${relevantFieldsWithCurrFieldTag.length}. Can not disambiguate!`);
+      nvdebug(` Number of them using tag ${field.tag} is ${relevantFieldsWithCurrFieldTag.length}. Can not disambiguate!`, debugDev);
       return false;
     }
 
@@ -128,7 +130,7 @@ function recordDisambiguateSharedSubfield6OccurrenceNumbers(record) {
     const newOccurrenceNumber = intToOccurrenceNumberString(newOccurrenceNumberAsInt);
     const pairedFields = fieldGetOccurrenceNumberPairs(field, record.fields);
 
-    nvdebug(` Reindex '${fieldToString(field)}' occurrence number and it's ${pairedFields.length} pair(s) using '${newOccurrenceNumber}'`, debug);
+    nvdebug(` Reindex '${fieldToString(field)}' occurrence number and it's ${pairedFields.length} pair(s) using '${newOccurrenceNumber}'`, debugDev);
 
     fieldResetOccurrenceNumber(field, newOccurrenceNumber, occurrenceNumber);
     pairedFields.forEach(pairedField => fieldResetOccurrenceNumber(pairedField, newOccurrenceNumber, occurrenceNumber));
@@ -172,7 +174,7 @@ export function recordResetSubfield6OccurrenceNumbers(record) { // Remove gaps
   record.fields.forEach(field => fieldResetSubfield6(field));
 
   function fieldResetSubfield6(field) {
-    nvdebug(`fieldResetSubfield6(${fieldToString(field)}), CURR:${currentInt}`, debug);
+    nvdebug(`fieldResetSubfield6(${fieldToString(field)}), CURR:${currentInt}`, debugDev);
     if (!field.subfields) {
       return;
     }
@@ -189,7 +191,7 @@ export function recordResetSubfield6OccurrenceNumbers(record) { // Remove gaps
     }
 
     const newIndex = mapCurrIndexToNewIndex(currIndex);
-    //nvdebug(`subfieldReset6(${subfieldToString(subfield)}): ${newIndex}`, debug);
+    //nvdebug(`subfieldReset6(${subfieldToString(subfield)}): ${newIndex}`, debugDev);
     subfield6ResetOccurrenceNumber(subfield, newIndex);
   }
 

package/src/reindexSubfield6OccurenceNumbers.test.js

@@ -3,7 +3,7 @@ import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from './reindexSubfield6OccurenceNumbers.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
-import createDebugLogger from 'debug';
+//import createDebugLogger from 'debug';
 
 generateTests({
   callback,
@@ -19,7 +19,7 @@ generateTests({
     }
   }
 });
-const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/reindexSubfield6OccurrenceNumbers:test');
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/reindexSubfield6OccurrenceNumbers:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
@@ -29,12 +29,7 @@ async function testValidatorFactory() {
   assert.equal(typeof validator.validate, 'function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
-  if (enabled === false) {
-    debug('TEST SKIPPED!');
-    return;
-  }
-
+async function callback({getFixture, fix = false}) {
   const validator = await validatorFactory();
   const record = new MarcRecord(getFixture('record.json'));
   const expectedResult = getFixture('expectedResult.json');

package/src/remove-041-zxx.js

@@ -0,0 +1,85 @@
+/*
+// remove-041-zxx.js
+//
+// https://wiki.helsinki.fi/xwiki/bin/view/rdasovellusohje/RDA-kuvailu%20MARC%2021%20-formaatilla/RDA-sovellusohje/008%20Kontrollikentt%C3%A4/#Hmp.35-37Kieli
+// "008-kielikoodi on sama kuin ensimmäinen 041-kentän a- (tai d-) osakenttä. Poikkeuksen muodostaa koodi zxx:
+//  jos tietueen 008ssa on kielikoodi zxx (ei kielellistä sisältöä, esim. soitinmusiikki), tietueessa ei voi olla 041 a- eikä d-osakenttää."
+// Effectively this means, that 'zxx' does not appear in 041!
+// Author(s): Nicholas Volk
+*/
+
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+
+import {fieldToString} from './utils.js';
+
+// const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:remove-041-zxx');
+
+
+
+
+export default function () {
+
+  return {
+    description: "Remove 'zxx' from f041",
+    validate, fix
+  };
+
+  function zxxRemoval041(record, validateMode) {
+    const fields041 = record.fields.filter(f => f.tag === '041');
+
+    return handleZxx(fields041);
+
+    function handleZxx(fields, result = []) {
+      const [currField, ...remainingFields] = fields;
+      if ( !currField) {
+        return result;
+      }
+      // Theoretically 'zxx' might mean something in ISO-639-3 or some other language code list:
+      if (!currField.subfields || currField.subfields.some(sf => sf.code === '2')) {
+        return handleZxx(remainingFields, result);
+      }
+      // Presumable 'zxx' is bad in any data subfield, not just 'a' and 'd':
+      const otherSubfields = currField.subfields.filter(sf => (!sf.code.match(/^[a-z]$/u) || sf.value !== 'zxx'));
+      if (otherSubfields.length === currField.subfields.length) {
+        return handleZxx(remainingFields, result);
+      }
+      const originalString = fieldToString(currField);
+      if (otherSubfields.length === 0) {
+        const message = `Remove '${originalString}'`;
+        if (!validateMode) {
+          record.removeField(currField);
+        }
+        return handleZxx(remainingFields, [...result, message]);
+      }
+      // Some subfields are removed:
+      if (validateMode) {
+        // NB! In validation field is not really deleted, and the non-deleted field might trigger other fixes (than won't be done to a deleted field) later on
+        const clonedField = clone(currField);
+        clonedField.subfields = otherSubfields;
+        const modifiedString = fieldToString(clonedField);
+        const message = `Modify '${originalString}' => '${modifiedString}`;
+        return handleZxx(remainingFields, [...result, message]);
+      }
+      currField.subfields = otherSubfields;
+      const modifiedString = fieldToString(currField);
+      const message = `Modify '${originalString}' => '${modifiedString}`;
+      return handleZxx(remainingFields, [...result, message]);
+    }
+  }
+
+  function fix(record, validateMode = false) {
+    const messages = zxxRemoval041(record, validateMode);
+
+    if (validateMode) {
+       return {message: messages, valid: messages.length === 0};
+    }
+    return {message: [], fix: messages, valid: true};
+  }
+
+
+  function validate(record) {
+    return fix(record, true);
+  }
+}
+

package/src/remove-041-zxx.test.js

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+//import createDebugLogger from 'debug';
+
+import validatorFactory from './remove-041-zxx.js';
+
+import {MarcRecord} from '@natlibfi/marc-record';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+generateTests({
+  callback,
+  path: [import.meta.dirname, '..', 'test-fixtures', 'remove-041-zxx'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
+  }
+});
+
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/drop-terms:test');
+
+async function testValidatorFactory() {
+  const validator = await validatorFactory();
+
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
+}
+
+async function callback({getFixture, fix = false}) {
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  //const expectedResult = new MarcRecord(getFixture('expectedResult.json'));
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    assert.deepEqual(result, expectedResult);
+    const originalRecord = new MarcRecord(getFixture('record.json'));
+    assert.deepEqual(record, originalRecord); // Validation should not change the record
+    return;
+  }
+
+  await validator.fix(record);
+  assert.deepEqual(record, new MarcRecord(expectedResult));
+}