@natlibfi/marc-record-validators-melinda 12.0.7 → 12.0.8

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/removeDuplicateDataFields.js

@@ -11,6 +11,8 @@ const LINKED_NOT_PROCESSED = 1;
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:removeDuplicateDataFields');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 export default function () {
   return {
@@ -19,7 +21,7 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug('Remove duplicate data fields');
+    nvdebug('Remove duplicate data fields', debugDev);
     const res = {message: [], fix: [], valid: true};
     removeDuplicateDatafields(record, true);
     // This can not really fail...
@@ -28,7 +30,7 @@ export default function () {
 
   function validate(record) {
     // Check max, and check number of different indexes
-    nvdebug('Validate record: duplicate data fields cause (t)error', debug);
+    nvdebug('Validate record: duplicate data fields cause (t)error', debugDev);
 
     const duplicates = removeDuplicateDatafields(record, false);
 
@@ -49,7 +51,7 @@ export default function () {
 
 /*
 function numberOfLinkageSubfields(field) {
-  nvdebug(`N of Linkage Subs(${fieldToString(field)})`);
+  nvdebug(`N of Linkage Subs(${fieldToString(field)})`, debugDev);
   const subfields = field.subfields.filter(sf => sf.code === '6' || sf.code === '8');
   return subfields.length;
 }
@@ -139,21 +141,21 @@ export function removeDuplicateSubfield8Chains(record, fix = true) {
 
   let removables = []; // for validation
 
-  //nvdebug("CHAIN-8");
+  //nvdebug("CHAIN-8", debugDev);
   const seenLinkingNumbers = recordGetAllSubfield8LinkingNumbers(record);
   if (seenLinkingNumbers.length === 0) {
     return removables;
   }
 
-  //nvdebug(`seen linking numbers ($8): ${seenLinkingNumbers.join(', ')}`, debug);
+  //nvdebug(`seen linking numbers ($8): ${seenLinkingNumbers.join(', ')}`, debugDev);
 
   seenLinkingNumbers.forEach(currLinkingNumber => {
     const linkedFields = recordGetFieldsWithSubfield8LinkingNumber(record, currLinkingNumber) //getFieldsWithSubfield8Index(base, baseIndex);
     // As/If there's just one occurrence number it should be fine to use normalizeOccurrenceNumber = true
     const normalizeOccurrenceNumber = true;
     const linkedFieldsAsString = fieldsToNormalizedString(linkedFields, currLinkingNumber, normalizeOccurrenceNumber, true);
-    //nvdebug(`Results for LINKING NUMBER ${currLinkingNumber}:`, debug);
-    //nvdebug(`${linkedFieldsAsString}`, debug);
+    //nvdebug(`Results for LINKING NUMBER ${currLinkingNumber}:`, debugDev);
+    //nvdebug(`${linkedFieldsAsString}`, debugDev);
 
     if (linkedFieldsAsString in seen)  {
       if (!removables.includes(linkedFieldsAsString)) {
@@ -161,15 +163,15 @@ export function removeDuplicateSubfield8Chains(record, fix = true) {
       }
 
       if (fix) {
-        //nvdebug(`$8 CHAIN FIX: REMOVE $8 GROUP: ${fieldsToString(linkedFields)}`, debug);
+        //nvdebug(`$8 CHAIN FIX: REMOVE $8 GROUP: ${fieldsToString(linkedFields)}`, debugDev);
         linkedFields.forEach(field => recordRemoveFieldOrSubfield8(record, field, currLinkingNumber));
         return;
       }
 
-      //nvdebug(`$8 VALIDATION: DUPLICATE DETECTED ${linkedFieldsAsString}`, debug);
+      //nvdebug(`$8 VALIDATION: DUPLICATE DETECTED ${linkedFieldsAsString}`, debugDev);
       return;
     }
-    //nvdebug(`$8 DOUBLE REMOVAL OR VALIDATION: ADD2SEEN ${linkedFieldsAsString}`, debug);
+    //nvdebug(`$8 DOUBLE REMOVAL OR VALIDATION: ADD2SEEN ${linkedFieldsAsString}`, debugDev);
     seen[linkedFieldsAsString] = 1;
     return;
   });
@@ -190,28 +192,28 @@ export function handleDuplicateSubfield8Chains(record, fix) {
 
   let seen = {};
 
-  //nvdebug("CHAIN-8");
+  //nvdebug("CHAIN-8", debugDev);
   const seenLinkingNumbers = recordGetAllSubfield8LinkingNumbers(record);
   if (seenLinkingNumbers.length === 0) {
     return;
   }
 
-  //nvdebug(`seen linking numbers ($8): ${seenLinkingNumbers.join(', ')}`, debug);
+  //nvdebug(`seen linking numbers ($8): ${seenLinkingNumbers.join(', ')}`, debugDev);
 
   seenLinkingNumbers.forEach(currLinkingNumber => {
     const linkedFields = recordGetFieldsWithSubfield8LinkingNumber(record, currLinkingNumber) //getFieldsWithSubfield8Index(base, baseIndex);
     // As/If there's just one occurrence number it should be fine to use normalizeOccurrenceNumber = true
     const normalizeOccurrenceNumber = false; //true;
     const linkedFieldsAsString = fieldsToNormalizedString(linkedFields, currLinkingNumber, normalizeOccurrenceNumber, true);
-    //nvdebug(`Results for LINKING NUMBER ${currLinkingNumber}:`, debug);
-    //nvdebug(`${linkedFieldsAsString}`, debug);
+    //nvdebug(`Results for LINKING NUMBER ${currLinkingNumber}:`, debugDev);
+    //nvdebug(`${linkedFieldsAsString}`, debugDev);
 
     if (linkedFieldsAsString in seen)  {
-      //nvdebug(`$8 CHAIN FIX: REMOVE $8 GROUP: ${fieldsToString(linkedFields)}`, debug);
+      //nvdebug(`$8 CHAIN FIX: REMOVE $8 GROUP: ${fieldsToString(linkedFields)}`, debugDev);
       linkedFields.forEach(field => newRecordRemoveFieldOrSubfield8(record, field, currLinkingNumber, fix));
       return;
     }
-    //nvdebug(`$8 DOUBLE REMOVAL OR VALIDATION: ADD2SEEN ${linkedFieldsAsString}`, debug);
+    //nvdebug(`$8 DOUBLE REMOVAL OR VALIDATION: ADD2SEEN ${linkedFieldsAsString}`, debugDev);
     seen[linkedFieldsAsString] = 1;
     return;
   });
@@ -223,12 +225,12 @@ function markIdenticalSubfield6Chains(chain, record) {
   const normalizeTag = chain.some(field => field.tag.substring(0, 1) === '1'); // 1XX can delete 7XX as well!
   const chainAsString = fieldsToNormalizedString(chain, 0, normalizeOccurrenceNumber, normalizeTag);
 
-  //nvdebug(`markIdenticalSubfield6Chains: ${chainAsString}`);
+  //nvdebug(`markIdenticalSubfield6Chains: ${chainAsString}`, debugDev);
   record.fields.forEach(f => compareWithChain(f));
 
 
   function compareWithChain(f) {
-    //nvdebug(`FIELD2CHAIN ${fieldToString(f)}`);
+    //nvdebug(`FIELD2CHAIN ${fieldToString(f)}`, debugDev);
     const otherChain = fieldToChain(f, record);
     // Not a lone field or chain (head) or ... or is-same-chain
     if (otherChain.length === 0 || sameField(chain[0], otherChain[0])) {
@@ -239,7 +241,7 @@ function markIdenticalSubfield6Chains(chain, record) {
     // Mark other chain as deleted:
     if (chainAsString === otherChainAsString) {
       otherChain.forEach(f => {
-        //nvdebug(` mark ${fieldToString(f)} as deleted ($6-chain)...`);
+        //nvdebug(` mark ${fieldToString(f)} as deleted ($6-chain)...`, debugDev);
         f.deleted = 1;
       });
       return;
@@ -260,7 +262,7 @@ function markIdenticalLoneFieldsAsDeletable(field, record) {
 
   // Mark fields as deleted:
   identicalLoneFields.forEach(f => {
-    //nvdebug(` mark ${fieldToString(f)} as deleted (lone field)...`);
+    //nvdebug(` mark ${fieldToString(f)} as deleted (lone field)...`, debugDev);
     f.deleted = 1;
   });
 
@@ -300,7 +302,7 @@ function acceptFieldsWithSubfield8(fieldsWithSubfield8, requireSingleTag = false
 
   // If linking number
   function anomaly8(linkingNumber) {
-    //nvdebug(`  Looking for anomalies in linkin number ${linkingNumber}`);
+    //nvdebug(`  Looking for anomalies in linkin number ${linkingNumber}`, debugDev);
     const relevantFields = fieldsWithSubfield8.filter(f => fieldHasLinkingNumber(f, linkingNumber));
     if (requireSingleTag) {
       return !isSingleTagLinkingNumber(linkingNumber, relevantFields, relevantFields[0].tag);
@@ -332,7 +334,7 @@ export function fieldToChain(field, record) {
   }
   const chain = newGetAllLinkedFields(field, record, true, true);
 
-  // nvdebug(` Chain contains ${chain.length} field(s)`);
+  // nvdebug(` Chain contains ${chain.length} field(s)`, debugDev);
   if (!isChainHead(field, chain)) { // newGetAllLinkedFields() marks relevant record.fields!
     return [];
   }
@@ -357,7 +359,7 @@ export function fieldToChain(field, record) {
     return [];
   }
 
-  //nvdebug(`Proceed with ${fieldsToString(chain)}`);
+  //nvdebug(`Proceed with ${fieldsToString(chain)}`, debugDev);
 
 
   return chain;
@@ -366,7 +368,7 @@ export function fieldToChain(field, record) {
 
 function fieldHandleDuplicateDatafields(field, record) {
   const chain = fieldToChain(field, record);
-  //nvdebug(` TRY TO HANDLE DUPLICATES OF '${fieldsToString(chain)}'`);
+  //nvdebug(` TRY TO HANDLE DUPLICATES OF '${fieldsToString(chain)}'`, debugDev);
 
   if (chain.length === 0) {
     return;
@@ -383,7 +385,7 @@ function fieldHandleDuplicateDatafields(field, record) {
   if (fieldsWithSubfield6.length === 0) {
 
     if (fieldsWithSubfield8.length === 0) { // chain.length === 1?
-      //nvdebug(` Trying to find duplicates of single field '${fieldToString(chain[0])}'`);
+      //nvdebug(` Trying to find duplicates of single field '${fieldToString(chain[0])}'`, debugDev);
       markIdenticalLoneFieldsAsDeletable(chain[0], record);
       return;
     }
@@ -401,8 +403,8 @@ function fieldHandleDuplicateDatafields(field, record) {
   }
 
 
-  //nvdebug(` NO HANDLER FOUND FOR '${fieldsToString(chain)}'`);
-  //nvdebug(`  N8s: ${fieldsWithSubfield6.length}`);
+  //nvdebug(` NO HANDLER FOUND FOR '${fieldsToString(chain)}'`, debugDev);
+  //nvdebug(`  N8s: ${fieldsWithSubfield6.length}`, debugDev);
 
 }
 

package/src/removeInferiorDataFields.js

@@ -12,7 +12,10 @@ import {fixComposition, precomposeFinnishLetters} from './normalize-utf8-diacrit
 // NB! This validator handles only full fields, and does not support subfield $8 removal.
 // Also, having multiple $8 subfields in same fields is not supported.
 // If this functionality is needed, see removeDuplicateDatafields.js for examples of subfield-only stuff.
+
 // const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:removeInferiorDataFields');
+//const debugData = debug.extend('data');
+//const debugDev = debug.extend('dev');
 
 export default function () {
   return {
@@ -21,7 +24,7 @@ export default function () {
   };
 
   function fix(record) {
-    //nvdebug('Fix record: remove inferior (eg. subset) data fields', debug);
+    //nvdebug('Fix record: remove inferior (eg. subset) data fields', debugDev);
     const res = {message: [], fix: [], valid: true};
     removeInferiorDatafields(record, true);
     // This can not really fail...
@@ -30,7 +33,7 @@ export default function () {
 
   function validate(record) {
     // Check max, and check number of different indexes
-    //nvdebug('Validate record: remove inferior (eg. subset) data fields', debug);
+    //nvdebug('Validate record: remove inferior (eg. subset) data fields', debugDev);
 
     const duplicates = removeInferiorDatafields(record, false);
 
@@ -43,14 +46,14 @@ export default function () {
 
 
 function deriveInferiorChains(fields, record) {
-  //nvdebug(`======= GOT ${fields.length} FIELDS TO CHAINIFY`);
+  //nvdebug(`======= GOT ${fields.length} FIELDS TO CHAINIFY`, debugDev);
   const hash = {};
 
   fields.forEach(f => fieldToChainToDeletables(f));
 
   return hash;
 
-  //nvdebug(`WP1: GOT ${todoList.length} CHAINS`);
+  //nvdebug(`WP1: GOT ${todoList.length} CHAINS`, debugDev);
 
 
   // here we map deletableStringObject[str] => field. The idea is to help debugging. We don't actually need the field object...
@@ -63,7 +66,7 @@ function deriveInferiorChains(fields, record) {
     }
     const chainAsString = fieldsToNormalizedString(chain, 0, true, true);
     const arr = deriveChainDeletables([chainAsString]);
-    //nvdebug(`GOT ${arr.length} DELETABLES FOR ${chainAsString}`);
+    //nvdebug(`GOT ${arr.length} DELETABLES FOR ${chainAsString}`, debugDev);
     arr.forEach(val => {
       if (!(val in hash)) {
         hash[val] = field;
@@ -116,16 +119,16 @@ function isRelevantChain6(field, record) {
 
 export function removeInferiorChains(record, fix = true) {
   const fields = record.fields.filter(f => isRelevantChain6(f, record));
-  //nvdebug(`WP2.0: GOT ${fields.length} chain(s)`);
+  //nvdebug(`WP2.0: GOT ${fields.length} chain(s)`, debugDev);
 
   const deletableChainsAsKeys = deriveInferiorChains(fields, record);
   const nChains = Object.keys(deletableChainsAsKeys).length;
-  //nvdebug(`WP2: GOT ${nChains} chain(s)`);
+  //nvdebug(`WP2: GOT ${nChains} chain(s)`, debugDev);
   if (nChains === 0) {
     return [];
   }
 
-  //nvdebug(`removeInferiorChains() has ${fields.length} fields-in-chain(s), and a list of ${nChains} deletable(s)`);
+  //nvdebug(`removeInferiorChains() has ${fields.length} fields-in-chain(s), and a list of ${nChains} deletable(s)`, debugDev);
 
   return innerRemoveInferiorChains(fields);
 
@@ -153,11 +156,11 @@ export function removeInferiorChains(record, fix = true) {
     if (chainContains1XX(chain)) {
       triggeringChain.forEach(f => sevenToOne(f, triggeringChain));
     }
-    //nvdebug(`iRIS6C: ${chainAsString}`);
+    //nvdebug(`iRIS6C: ${chainAsString}`, debugDev);
     const deletedString = fieldsToString(chain);
     const message = `DEL: '${deletedString}'  REASON: '${fieldsToString(triggeringChain)}'`;
     if (fix) {
-      //nvdebug(`INFERIOR $6 CHAIN REMOVAL: ${message}}`, debug);
+      //nvdebug(`INFERIOR $6 CHAIN REMOVAL: ${message}}`, debugDev);
       chain.forEach(field => record.removeField(field));
     }
     return innerRemoveInferiorChains(remainingFields, [...deletedStringsArray, message]);
@@ -197,7 +200,7 @@ function deriveIndividualDeletables490(todoList, deletables = []) {
   if (fieldAsString === undefined) {
     return deletables;
   }
-  //nvdebug(`PROCESS ${fieldAsString}`);
+  //nvdebug(`PROCESS ${fieldAsString}`, debugDev);
   if (!fieldAsString.match(/^490/u)) {
     return deriveIndividualDeletables490(stillToDo, deletables);
   }
@@ -220,13 +223,14 @@ function deriveIndividualDeletables490(todoList, deletables = []) {
 
   /*
   if (arr.length) {
-    nvdebug(`${arr.length} derivation(s) for ${fieldAsString}`);
-    nvdebug(arr.join('\n'));
+    nvdebug(`${arr.length} derivation(s) for ${fieldAsString}`, debugDev);
+    nvdebug(arr.join('\n'), debugDev);
   }
   */
   return arr;
 }
 
+// eslint-disable-next-line max-lines-per-function
 function deriveIndividualDeletables(record) {
   const todoList = record.fields.map(f => fieldToString(f));
   //const finishedRecord = encodingLevelIsBetterThanPrepublication(getEncodingLevel(record));
@@ -305,8 +309,8 @@ function deriveIndividualDeletables(record) {
       if (tmp !== currString) {
         return processTodoList([tmp, ...stillToDo, ...moreToDo], [...deletables, tmp]);
       }
-      //nvdebug(`505 ORIGINAL: '${fieldAsString}'`)
-      //nvdebug(`505 DERIVATE: '${tmp}'`)
+      //nvdebug(`505 ORIGINAL: '${fieldAsString}'`, debugDev)
+      //nvdebug(`505 DERIVATE: '${tmp}'`, debugDev)
     }
 
     if (currString.match(/^594 ## ‡a Ei vastaanotettu ‡5 FENNI$/u)) { // MELKEHITYS-3147
@@ -319,11 +323,11 @@ function deriveIndividualDeletables(record) {
     // MET-381: remove occurence number TAG-00, if TAG-NN existists
     if (currString.match(/^880.* ‡6 [0-9][0-9][0-9]-(?:[1-9][0-9]|0[1-9])/u)) {
       const tmp = currString.replace(/( ‡6 [0-9][0-9][0-9])-[0-9]+/u, '$1-00');
-      //nvdebug(`MET-381: ADD TO DELETABLES: '${tmp}'`);
+      //nvdebug(`MET-381: ADD TO DELETABLES: '${tmp}'`, debugDev);
       //deletableStringsArray.push(tmp);
       if (tmp.match(/ ‡6 [0-9][0-9][0-9]-00\/[^ ]+ /u)) {
         const tmp2 = tmp.replace(/( ‡6 [0-9][0-9][0-9]-00)[^ ]+/u, '$1');
-        //nvdebug(`MET-381: ADD TO DELETABLES: '${tmp2}'`);
+        //nvdebug(`MET-381: ADD TO DELETABLES: '${tmp2}'`, debugDev);
         return processTodoList([...stillToDo, ...moreToDo], [...deletables, tmp, tmp2]);
       }
       return processTodoList([...stillToDo, ...moreToDo], [...deletables, tmp]);
@@ -345,13 +349,13 @@ function deriveIndividualDeletables(record) {
   }
 
   function getAccentlessVersion(string) { // MET-527
-    //nvdebug(`START: '${string}`);
+    //nvdebug(`START: '${string}`, debugDev);
     // This is a sanity check: if precomposition does something, there's something wrong, and we don't want to proceed..
     if (string !== precomposeFinnishLetters(string)) {
       return [];
     }
     const accentless = String(fixComposition(string)).replace(/\p{Diacritic}/gu, '');
-    //nvdebug(`FROM '${string}'\n  TO '${accentless}'`);
+    //nvdebug(`FROM '${string}'\n  TO '${accentless}'`, debugDev);
     if (accentless === string) { // Don't self-destruct
       return [];
     }
@@ -408,8 +412,8 @@ export function removeIndividualInferiorDatafields(record, fix = true) { // No $
   const deletableFieldsAsStrings = deriveIndividualDeletables(record);
   const deletableFieldsAsNormalizedStrings = deriveIndividualNormalizedDeletables(record);
 
-  // nvdebug(`Deletables:\n ${deletableFieldsAsStrings.join('\n ')}`);
-  // nvdebug(`Normalized deletables:\n ${deletableFieldsAsNormalizedStrings.join('\n ')}`);
+  // nvdebug(`Deletables:\n ${deletableFieldsAsStrings.join('\n ')}`, debugDev);
+  // nvdebug(`Normalized deletables:\n ${deletableFieldsAsNormalizedStrings.join('\n ')}`, debugDev);
 
   const hits = record.fields.filter(field => isDeletableField(field));
 
@@ -417,7 +421,7 @@ export function removeIndividualInferiorDatafields(record, fix = true) { // No $
 
   if (fix) {
     hits.forEach(field => {
-      //nvdebug(`Remove inferior field: ${fieldToString(field)}`, debug);
+      //nvdebug(`Remove inferior field: ${fieldToString(field)}`, debugDev);
       record.removeField(field);
     });
   }
@@ -445,8 +449,8 @@ export function removeInferiorDatafields(record, fix = true) {
   const removables6 = removeInferiorChains(record, fix); // Lone subfield $6 chains
   // HOW TO HANDLE $6+$8 combos? Skipping is relatively OK.
 
-  //nvdebug(`REMOVABLES:\n  ${removables.join('\n  ')}`, debug);
-  //nvdebug(`REMOVABLES 6:\n  ${removables6.join('\n  ')}`, debug);
+  //nvdebug(`REMOVABLES:\n  ${removables.join('\n  ')}`, debugDev);
+  //nvdebug(`REMOVABLES 6:\n  ${removables6.join('\n  ')}`, debugDev);
 
   const removablesAll = removables.concat(removables6); //.concat(removables8);
 

package/src/resolveOrphanedSubfield6s.js

@@ -5,6 +5,8 @@ import {fieldHasWantedTagAndOccurrenceNumber, isValidSubfield6, subfield6GetOccu
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:resolveOrphanedSubfield6s');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 export default function () {
   return {
@@ -13,7 +15,7 @@ export default function () {
   };
 
   function fix(record) {
-    nvdebug('Fix SF6 orphaned occurrence numbers');
+    nvdebug('Fix SF6 orphaned occurrence numbers', debugDev);
     const res = {message: [], fix: [], valid: true};
     //message.fix = [];
 
@@ -26,7 +28,7 @@ export default function () {
 
   function validate(record) {
     // Check max, and check number of different indexes
-    nvdebug('Validate SF6 orphaned occurrence numbers', debug);
+    nvdebug('Validate SF6 orphaned occurrence numbers', debugDev);
     const fieldsContainingSubfield6 = record.fields.filter(field => fieldHasSubfield(field, '6'));
 
     const orphanedFields = getOrphanedFields(fieldsContainingSubfield6);
@@ -77,7 +79,7 @@ function findPairForSubfield6OccurrenceNumber(subfield6, myTag, candPairFields)
   if (!isValidSubfield6(subfield6)) {
     return undefined;
   }
-  //nvdebug(`LOOKING FOR PAIR: ${myTag} ${subfieldToString(subfield6)}`);
+  //nvdebug(`LOOKING FOR PAIR: ${myTag} ${subfieldToString(subfield6)}`, debugDev);
   candPairFields.forEach(field => fieldToString(field));
 
   // Only valid $6 value that fails to map to another field is iffy...
@@ -88,7 +90,7 @@ function findPairForSubfield6OccurrenceNumber(subfield6, myTag, candPairFields)
     return undefined;
   }
   const tagAndOccurrenceNumber = `${myTag}-${occurrenceNumber}`;
-  //nvdebug(`Try to find occurrence number ${tagAndOccurrenceNumber} in field ${referredTag}...`);
+  //nvdebug(`Try to find occurrence number ${tagAndOccurrenceNumber} in field ${referredTag}...`, debugDev);
   //const relevantFields = fields.filter(field => field.tag === referredTag && field.subfields.some(sf => subfield6GetOccurrenceNumber(sf) === occurrenceNumber));
   const relevantFields = candPairFields.filter(field => field.tag === referredTag && fieldHasWantedTagAndOccurrenceNumber(field, tagAndOccurrenceNumber));
   if (relevantFields.length === 0) {

package/src/sortSubfields.js

@@ -141,7 +141,7 @@ function getSubfieldSortOrder(field) {
     return entry[0].sortOrder;
   }
   if (!['300'].includes(field.tag)) { // Lis tags which use normal $a...$z order here!
-    nvdebug(`WARNING!\tNo subfield order found for ${field.tag}.`);
+    nvdebug(`WARNING!\tNo subfield order found for ${field.tag}.`, debugDev);
   }
   return [];
 }
@@ -230,15 +230,15 @@ export function sortAdjacentSubfields(field, externalSortOrder = []) {
   swapSubfields(field, controlSubfieldOrder);
 
   const sortOrderForField = externalSortOrder.length > 0 ? externalSortOrder : getSubfieldSortOrder(field);
-  //nvdebug(`INTERMEDIATE SUBFIELD ORDER FOR ${field.tag}: ${sortOrderForField.join(', ')}`);
+  //nvdebug(`INTERMEDIATE SUBFIELD ORDER FOR ${field.tag}: ${sortOrderForField.join(', ')}`, debugDev);
 
   const defaultSortOrder = finnishWay ? defaultSortOrderFinns : defaultSortOrderOthers; // $2 vs $0
   const subfieldOrder = sortOrderForField.length > 0 ? sortOrderForField : defaultSortOrder;
-  //nvdebug(`FINAL SUBFIELD ORDER (FINNISH=${finnishWay}) FOR ${field.tag}: ${subfieldOrder.join(', ')}`);
+  //nvdebug(`FINAL SUBFIELD ORDER (FINNISH=${finnishWay}) FOR ${field.tag}: ${subfieldOrder.join(', ')}`, debugDev);
   //if (sortOrder === null) { return field; } //// Currently always sort..
-  //nvdebug(`IN:  ${fieldToString(field)}`);
+  //nvdebug(`IN:  ${fieldToString(field)}`, debugDev);
   swapSubfields(field, subfieldOrder);
-  //nvdebug(`OUT: ${fieldToString(field)}`);
+  //nvdebug(`OUT: ${fieldToString(field)}`, debugDev);
 
   return field;
 }

package/src/stripPunctuation.js

@@ -8,9 +8,11 @@
 import {fieldGetFixedString, fieldNeedsModification, fieldStripPunctuation} from './punctuation2.js';
 import createDebugLogger from 'debug';
 
-import {fieldToString} from './utils.js';
+import {fieldToString, nvdebug} from './utils.js';
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/punctuation2');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
 
 const description =  'Strip punctuation in data fields';
 
@@ -21,14 +23,14 @@ export default function () {
   };
 
   function fix(record) {
-    debug(`${description}: fixer`);
+    nvdebug(`${description}: fixer`, debugDev);
     const res = {message: [], fix: [], valid: true};
     record.fields.forEach(f => fieldStripPunctuation(f));
     return res;
   }
 
   function validate(record) {
-    debug(`${description}: validate`);
+    nvdebug(`${description}: validate`, debugDev);
 
     const fieldsNeedingModification = record.fields.filter(f => fieldNeedsModification(f, false));