@natlibfi/marc-record-validators-melinda 11.3.1 → 11.3.2

package/src/merge-fields/mergeField.js

@@ -0,0 +1,187 @@
+//import {MarcRecord} from '@natlibfi/marc-record';
+import createDebugLogger from 'debug';
+import {fieldHasSubfield, fieldToString, fieldsToString, fieldsAreIdentical, nvdebug, hasCopyright, removeCopyright, subfieldToString} from '../utils';
+import {fieldGetOccurrenceNumberPairs} from '../subfield6Utils.js';
+import {cloneAndNormalizeFieldForComparison, cloneAndRemovePunctuation} from '../normalizeFieldForComparison';
+import {mergeOrAddSubfield} from './mergeOrAddSubfield';
+import {mergeIndicators} from './mergeIndicator';
+import {mergableTag} from './mergableTag';
+import {getCounterpart} from './counterpartField';
+//import {default as normalizeEncoding} from '@natlibfi/marc-record-validators-melinda/dist/normalize-utf8-diacritics';
+//import {postprocessRecords} from './mergeOrAddPostprocess.js';
+//import {preprocessBeforeAdd} from './processFilter.js';
+
+//import fs from 'fs';
+//import path from 'path';
+
+
+//const defaultConfig = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'src', 'reducers', 'config.json'), 'utf8'));
+
+// Specs: https://workgroups.helsinki.fi/x/K1ohCw (though we occasionally differ from them)...
+
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:mergeField');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+// NB! Can be do this via config.json?
+function removeEnnakkotieto(field) {
+  const tmp = field.subfields.filter(subfield => subfield.code !== 'g' || subfield.value !== 'ENNAKKOTIETO.');
+  // remove only iff some other subfield remains
+  if (tmp.length > 0) { // eslint-disable-line functional/no-conditional-statements
+    field.subfields = tmp; // eslint-disable-line functional/immutable-data
+  }
+}
+
+
+function copyrightYearHack(baseRecord, baseField, sourceField) {
+  if (baseField.tag !== '264' || sourceField.tag !== '260') {
+    return;
+  }
+  const relevantSubfields = sourceField.subfields.filter(sf => sf.code === 'c' && hasCopyright(sf.value));
+
+  relevantSubfields.forEach(sf => {
+    // Add new:
+    const value = sf.value.replace(/\.$/u, '');
+    baseRecord.insertField({'tag': '264', 'ind1': ' ', 'ind2': '4', 'subfields': [{'code': 'c', value}]});
+    // Modify original subfield:
+    sf.value = removeCopyright(sf.value); // eslint-disable-line functional/immutable-data
+  });
+}
+
+// eslint-disable-next-line max-params
+function mergeField2(baseRecord, baseField, sourceField, config, candFieldPairs880 = []) {
+  //// Identical fields
+  // No need to check every subfield separately.
+  // Also no need to postprocess the resulting field.
+  if (fieldToString(baseField) === fieldToString(sourceField)) {
+    return baseRecord;
+  }
+
+  // If a base ennakkotieto is merged with real data, remove ennakkotieto subfield:
+  // (If our prepub normalizations are ok, this should not be needed.
+  //  However, it's simple and works well enough, so let's keep it here.)
+  if (fieldHasSubfield(baseField, 'g', 'ENNAKKOTIETO.') && !fieldHasSubfield(sourceField, 'g', 'ENNAKKOTIETO.')) { // eslint-disable-line functional/no-conditional-statements
+    removeEnnakkotieto(baseField);
+    baseField.merged = 1; // eslint-disable-line functional/immutable-data
+  }
+
+  copyrightYearHack(baseRecord, baseField, sourceField);
+
+  mergeIndicators(baseField, sourceField, config);
+
+
+  // We want to add the incoming subfields without punctuation, and add puctuation later on.
+  // (Cloning is harmless, but probably not needed.)
+  // NEW: we also drag the normalized version along. It is needed for the merge-or-add decision
+  const normalizedSourceField = cloneAndNormalizeFieldForComparison(sourceField); // This is for comparison
+  const strippedSourceField = cloneAndRemovePunctuation(sourceField); // This is for adding subfields
+
+  //nvdebug(`  MERGING SUBFIELDS OF '${fieldToString(sourceField)}' (original)`, debugDev);
+  //nvdebug(`  MERGING SUBFIELDS OF '${fieldToString(normalizedSourceField)}' (comparison)`, debugDev);
+  nvdebug(`  MERGING SUBFIELDS OF '${fieldToString(strippedSourceField)}' (merge/add)`, debugDev);
+
+  sourceField.subfields.forEach((originalSubfield, index) => {
+  //strippedSourceField.subfields.forEach((subfieldForMergeOrAdd, index) => {
+    const normalizedSubfield = normalizedSourceField.subfields[index];
+    const punctlessSubfield = strippedSourceField.subfields[index];
+    const originalBaseValue = fieldToString(baseField);
+    nvdebug(`  TRYING TO MERGE SUBFIELD '${subfieldToString(originalSubfield)}' TO '${originalBaseValue}'`, debugDev);
+
+    const subfieldData = {'tag': sourceField.tag, 'code': originalSubfield.code, 'originalValue': originalSubfield.value, 'normalizedValue': normalizedSubfield.value, 'punctuationlessValue': punctlessSubfield.value};
+
+    mergeOrAddSubfield(baseField, subfieldData, candFieldPairs880); // candSubfield);
+    const newValue = fieldToString(baseField);
+    if (originalBaseValue !== newValue) { // eslint-disable-line functional/no-conditional-statements
+      nvdebug(`   SUBFIELD MERGE RESULT: '${newValue}'`, debugDev);
+      //debug(`   TODO: sort subfields, handle punctuation...`);
+    }
+    //else { debugDev(`  mergeOrAddSubfield() did not add '‡${fieldToString(subfieldForMergeOrAdd)}' to '${originalValue}'`); }
+
+  });
+}
+
+
+function skipMergeField(baseRecord, sourceField, config) {
+  if (!mergableTag(sourceField.tag, config)) {
+    nvdebug(`skipMergeField(): field '${fieldToString(sourceField)}' listed as skippable!`, debugDev);
+    return true;
+  }
+
+  // Skip duplicate field:
+  if (baseRecord.fields.some(baseField => !baseField.mergeCandidate && fieldsAreIdentical(sourceField, baseField))) {
+    nvdebug(`skipMergeField(): field '${fieldToString(sourceField)}' already exists! No merge required!`, debugDev);
+    sourceField.deleted = 1; // eslint-disable-line functional/immutable-data
+    return true;
+  }
+
+  return false;
+}
+
+function sourceRecordIsBetter(baseField, sourceField) {
+  if (!baseField.subfields) {
+    return;
+  }
+  // MELINDA-8978: prefer Asteri version
+  if (isAsteriField(sourceField) && !isAsteriField(baseField)) {
+    return 1;
+  }
+
+  function isAsteriField(field) {
+    if (field.subfields.some(sf => sf.code === '0' && sf.value.match(/^\((?:FI-ASTERI-[NW]|FIN1[13])\)[0-9]{9}$/u))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function swapDataBetweenFields(field1, field2) {
+  // NB! Does not support controlfields yet! Add support if the need arises.
+  if (field1.subfields) { // If field1 has subfields, then also field2 has them. No need to check the other field here.
+    swapNamedData('ind1');
+    swapNamedData('ind2');
+    swapNamedData('subfields');
+    return;
+  }
+  return;
+
+  function swapNamedData(name) {
+    const data = field1[name]; // eslint-disable-line functional/immutable-data
+    field1[name] = field2[name]; // eslint-disable-line functional/immutable-data
+    field2[name] = data; // eslint-disable-line functional/immutable-data
+  }
+
+}
+
+export function mergeField(baseRecord, sourceRecord, sourceField, config) {
+  nvdebug(`SELF: ${fieldToString(sourceField)}`, debugDev);
+
+  sourceField.mergeCandidate = true; // eslint-disable-line functional/immutable-data
+  // skip duplicates and special cases:
+  if (skipMergeField(baseRecord, sourceField, config)) {
+    nvdebug(`mergeField(): don't merge '${fieldToString(sourceField)}'`, debugDev);
+    delete sourceField.mergeCandidate; // eslint-disable-line functional/immutable-data
+    return false;
+  }
+
+  nvdebug(`mergeField(): Try to merge '${fieldToString(sourceField)}'.`, debugDev);
+  const counterpartField = getCounterpart(baseRecord, sourceRecord, sourceField, config);
+
+  if (counterpartField) {
+    if (sourceRecordIsBetter(counterpartField, sourceField)) { // eslint-disable-line functional/no-conditional-statements
+      swapDataBetweenFields(counterpartField, sourceField);
+    }
+
+    const candFieldPairs880 = sourceField.tag === '880' ? undefined : fieldGetOccurrenceNumberPairs(sourceField, sourceRecord.fields);
+    nvdebug(`mergeField(): Got counterpart: '${fieldToString(counterpartField)}'. Thus try merge...`, debugDev);
+    nvdebug(`PAIR: ${candFieldPairs880 ? fieldsToString(candFieldPairs880) : 'NADA'}`, debugDev);
+    mergeField2(baseRecord, counterpartField, sourceField, config, candFieldPairs880);
+    sourceField.deleted = 1; // eslint-disable-line functional/immutable-data
+    delete sourceField.mergeCandidate; // eslint-disable-line functional/immutable-data
+    return true;
+  }
+  // NB! Counterpartless field is inserted to 7XX even if field.tag says 1XX:
+  debugDev(`mergeField(): No mergable counterpart found for '${fieldToString(sourceField)}'.`);
+  delete sourceField.mergeCandidate; // eslint-disable-line functional/immutable-data
+  return false;
+}
+

package/src/merge-fields/mergeIndicator.js

@@ -0,0 +1,185 @@
+import createDebugLogger from 'debug';
+import {fieldToString, marc21GetTagsLegalInd1Value, marc21GetTagsLegalInd2Value, nvdebug} from '../utils';
+
+// Specs: https://workgroups.helsinki.fi/x/K1ohCw (though we occasionally differ from them)...
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:merge-fields:mergeIndicator');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+const ind1NonFilingChars = ['130', '630', '730', '740'];
+const ind2NonFilingChars = ['222', '240', '242', '243', '245', '830'];
+
+
+export function mergeIndicators(toField, fromField, config) {
+  // NB! For non-filing indicators we deem that bigger is better. This is a bit quick'n'dirty, as usual.
+  // We could and should checks the relevant article length (using language information whilst doing it).
+  // However, this is a task for record internal fixer, not merge.
+  //
+  // For other indicators the situation is trickier, as we don't know which one is the good value.
+  //
+  // NB! We could add fixes for various other indicator types as well. However, it gets quickly pretty ad hoc.
+  // nvdebug(fieldToString(toField), debugDev);
+  // nvdebug(fieldToString(fromField), debugDev);
+
+  mergeIndicator1(toField, fromField, config);
+  mergeIndicator2(toField, fromField, config);
+
+  function getIndicatorPreferredValues(tag, indicatorNumber, config) {
+    const cands = getIndicatorPreferredValuesForGivenTag(tag, indicatorNumber, config);
+    // More complex systems where multiple indicators have same priority are objects.
+    // Example: field 506 might return {"0": 1, "1": 1, " ": 2}
+    // Here indicator values '0' and '1' share top priority 1, and '#' is of lesser importance, namely 2.
+    if (Array.isArray(cands) || typeof cands === 'object') {
+      return cands;
+    }
+    if (typeof cands === 'string') { // single cand as string (seen in json in the past), though now they should all be arrays
+      return cands.split('');
+    }
+
+    return [];
+
+    function getIndicatorPreferredValuesForGivenTag(tag, indicatorNumber, config) {
+      const preferredValues = indicatorNumber === 1 ? config.indicator1PreferredValues : config.indicator2PreferredValues;
+      nvdebug(`${tag} IND${indicatorNumber}: get preferred values...\nCONFIG: ${JSON.stringify(config)}`, debugDev);
+      if (preferredValues) {
+        //nvdebug(`${tag} PREF VALS: ${JSON.stringify(preferredValues)}`, debugDev);
+        if (tag in preferredValues) {
+          return preferredValues[tag];
+        }
+      }
+
+      // Easter Egg #1: Use good-ish hard-coded defaults as not defined by user:
+      if (indicatorNumber === 1 && ind1NonFilingChars.includes(tag)) {
+        return '9876543210 ';
+      }
+      if (indicatorNumber === 2 && ind2NonFilingChars.includes(tag)) {
+        return '9876543210 ';
+      }
+
+      // Easter Egg #2: Marc21 standard has just one value for given indicator, so prefer it:
+      const cands = indicatorNumber === 1 ? marc21GetTagsLegalInd1Value(tag) : marc21GetTagsLegalInd2Value(tag);
+      if (cands) {
+        if (typeof cands === 'string' && cands.length === 1) { // single cand
+          return [cands];
+        }
+        if (Array.isArray(cands) && cands.length === 1) {
+          return cands;
+        }
+      }
+
+      return [];
+    }
+  }
+
+  function getPreferredValue(preferences, val1, val2) {
+    const i1 = scoreValue(preferences, val1);
+    const i2 = scoreValue(preferences, val2);
+    if (i1 === -1) {
+      return i2 === -1 ? undefined : val2;
+    }
+    if (i2 === -1) {
+      return val1;
+    }
+    // The sooner, the better:
+    return i1 < i2 ? val1 : val2;
+
+    function scoreValue(preferences, val) {
+      if (Array.isArray(preferences)) {
+        return preferences.indexOf(val);
+      }
+      // preferences may be an object, since diffent values can return same score
+      // (eg. 506 ind1 values '0' and '1' are equal but better than '#')
+      if (!(val in preferences)) {
+        return -1;
+      }
+      return preferences[val];
+    }
+  }
+
+
+  function fieldIsFenniKept(field) {
+    return field.subfields && field.subfields.some(sf => sf.code === '9' && sf.value === 'FENNI<KEEP>');
+  }
+
+  function mergeIndicator1(toField, fromField, config) {
+    if (toField.ind1 === fromField.ind1) {
+      return; // Do nothing
+    }
+
+    // MRA-300: If source contains the (un)holy $9 FENNI<KEEP>, we prefer that value regardless of whatever...
+    if (!fieldIsFenniKept(toField) && fieldIsFenniKept(fromField)) {
+      toField.ind1 = fromField.ind1; // eslint-disable-line functional/immutable-data
+      return;
+    }
+
+
+    const preferredValues = getIndicatorPreferredValues(toField.tag, 1, config);
+
+    if (preferredValues) {
+      //nvdebug(`Try to merge indicator 1: '${toField.ind1}' vs '${fromField.ind1}'`, debugDev);
+      //nvdebug(`PREF VALS: ${preferredValues}`, debugDev);
+      const preferredValue = getPreferredValue(preferredValues, fromField.ind1, toField.ind1);
+      if (typeof preferredValue !== 'undefined') {
+        //nvdebug(`${preferredValue} WINS!`, debugDev);
+        toField.ind1 = preferredValue; // eslint-disable-line functional/immutable-data
+        return;
+      }
+      //nvdebug(`No winner found indicator 1: '${toField.ind1}' vs '${fromField.ind1}', keep '${toField.ind1}'`, debugDev);
+      //return;
+    }
+    //nvdebug(`TAG '${toField.tag}': No rule to merge indicator 1: '${toField.ind1}' vs '${fromField.ind1}', keep '${toField.ind1}'`, debugDev);
+  }
+
+
+  function publisherTagSwapHack(toField, fromField) {
+    // NB! Note that field 264.ind2==3 maps to $efg in field 260, so it is not relevant *here*:
+    // (Not sure whether our ind2 sanity check list should contain '4' (copyright year) as well:)
+    if (toField.tag !== '260' || fromField.tag !== '264' || !['0', '1', '2'].includes(fromField.ind2)) {
+      return;
+    }
+    // Field 264 IND2 contains information that can not be coded into field 260.
+
+    // However, 260 contains data that cannot be converted to 264 as well
+    if (toField.subfields.some(sf => ['e', 'f', 'g'].includes(sf.code))) {
+      nvdebug(`WARNING: can not change base 260 to 264 as it contains $e, $f and/or $g. Source IND2 info lost.`, debugDev);
+      nvdebug(` ${fieldToString(toField)}\n ${fieldToString(fromField)}`, debugDev);
+      return;
+    }
+
+    // Convert 260 to 264 so that no information is lost:
+    nvdebug(`Apply base 260->264 tag swap hack`, debugDev);
+    nvdebug(` ${fieldToString(toField)}\n ${fieldToString(fromField)}`, debugDev);
+
+    toField.tag = '264'; // eslint-disable-line functional/immutable-data
+    toField.ind2 = fromField.ind2; // eslint-disable-line functional/immutable-data
+  }
+
+  function mergeIndicator2(toField, fromField, config) {
+    if (toField.ind2 === fromField.ind2) {
+      return; // Do nothing
+    }
+
+    //nvdebug(`Merge IND2`, debugDev);
+    //nvdebug(` ${fieldToString(toField)}\n ${fieldToString(fromField)}`, debugDev);
+
+
+    publisherTagSwapHack(toField, fromField); // Easter egg/hack for base-260 vs source-264
+
+    // If source contains $9 FENNI<KEEP>, we might prefer it?
+
+    //nvdebug(`Try to merge indicator 2: '${toField.ind2}' vs '${fromField.ind2}'`, debugDev);
+    const preferredValues = getIndicatorPreferredValues(toField.tag, 2, config);
+
+    if (preferredValues) {
+      //nvdebug(`  Try to merge indicator 2. Got preferred values '${preferredValues}'`, debugDev);
+      const preferredValue = getPreferredValue(preferredValues, fromField.ind2, toField.ind2);
+      if (typeof preferredValue !== 'undefined') {
+        toField.ind2 = preferredValue; // eslint-disable-line functional/immutable-data
+        return;
+      }
+    }
+
+  }
+
+}

package/src/merge-fields/mergeOrAddPostprocess.js

@@ -0,0 +1,56 @@
+// This field should be renamed, as it is called also from outside megre.
+
+//import {MarcRecord} from '@natlibfi/marc-record';
+import {fieldFixPunctuation} from '../punctuation2';
+import {fieldRemoveDuplicateSubfields} from './removeDuplicateSubfields';
+import {sortAdjacentSubfields} from '../sortSubfields';
+import {sortAdjacentESubfields} from '../sortRelatorTerms';
+
+function postprocessBaseRecord(base) {
+
+  base.fields.forEach(field => {
+    // NB! Relator terms are now expanded and translated already at preprocess stage!
+
+    // remove merge-specific information:
+    if (field.merged) { // eslint-disable-line functional/no-conditional-statements
+      // Field level ideas about things that could be done here:
+      // - Fix indicators?
+      // Record level fixes should be implemented as validators/fixers
+      // in marc-record-validators-melinda and ust called from here.
+      fieldRemoveDuplicateSubfields(field);
+      fieldFixPunctuation(field); // NB! This will fix only fields with merged content
+      sortAdjacentSubfields(field); // Put the added $e subfield to proper places.
+      sortAdjacentESubfields(field); // Sort $e subfields with each other
+      fieldFixPunctuation(field);
+
+      delete field.merged; // eslint-disable-line functional/immutable-data
+    }
+
+    if (field.useExternalEndPunctuation) { // eslint-disable-line functional/no-conditional-statements
+      delete field.useExternalEndPunctuation; // eslint-disable-line functional/immutable-data
+    }
+
+    if (field.added) { // eslint-disable-line functional/no-conditional-statements
+      delete field.added; // eslint-disable-line functional/immutable-data
+    }
+
+    /*
+    if (field.deleted) { // eslint-disable-line functional/no-conditional-statements
+      delete field.deleted; // eslint-disable-line functional/immutable-data
+    }
+*/
+
+  });
+}
+
+
+function removeDeletedFields(record) {
+  // remove fields that are marked as deleted:
+  record.fields = record.fields.filter(f => !f.deleted); // eslint-disable-line functional/immutable-data
+}
+
+
+export function postprocessRecords(base, source) {
+  postprocessBaseRecord(base);
+  removeDeletedFields(source); // So that we may know what was used, and what not.
+}

package/src/merge-fields/mergeOrAddSubfield.js

@@ -0,0 +1,218 @@
+import createDebugLogger from 'debug';
+import {cloneAndNormalizeFieldForComparison} from '../normalizeFieldForComparison.js';
+import {normalizeAs, normalizeControlSubfieldValue} from '../normalize-identifiers';
+import {fieldHasSubfield, fieldToString, isControlSubfieldCode, nvdebug, subfieldIsRepeatable, subfieldToString} from '../utils.js';
+import {mergeSubfield} from './mergeSubfield.js';
+import {sortAdjacentSubfields} from '../sortSubfields'; //'./sortSubfields.js';
+
+import {valueCarriesMeaning} from './worldKnowledge.js';
+import {resetSubfield6Tag} from '../subfield6Utils.js';
+
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:mergeOrAddSubfield');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+function catalogingSourceModifyingAgencyCandIsOriginalCatalogingSourceAgencyInTargetField(targetField, candSubfieldData) {
+  if (targetField.tag !== '040' || candSubfieldData.code !== 'd') {
+    return false;
+  }
+  nvdebug(`${fieldToString(targetField)} vs $d ${candSubfieldData.originalValue}}`, debugDev);
+  // Add hard-coded exceptions here
+  if (targetField.subfields.some(sf => sf.code === 'a' && sf.value === candSubfieldData.originalValue)) {
+    nvdebug('040‡d matched 040‡a', debugDev);
+    return true;
+  }
+  return false;
+}
+
+function ennakkotietoInSubfieldG(candSubfieldData) {
+  if (candSubfieldData.code === 'g' && ['ENNAKKOTIETO.', 'ENNAKKOTIETO'].includes(candSubfieldData.originalValue)) {
+    // Skip just ‡g subfield or the whole field?
+    // We decided to skip just this subfield. We want at least $0 and maybe even more from ennakkotieto.
+    debugDev('Skip ‡g ENNAKKOTIETO.');
+    return true;
+  }
+  return false;
+}
+
+
+function mergeOrAddSubfieldNotRequiredSpecialCases(targetField, candSubfieldData) {
+
+  // Don't bring WHATEVER<KEEP> from source 7XX to base 1XX.
+  // Exceptionally we can merge <KEEP>ed 7XX with un-<KEEP>ed 1XX as 1XX should not use <KEEP>s.
+  if (targetField.tag.charAt(0) === '1' && candSubfieldData.tag.charAt(0) === '7' && candSubfieldData.code === '9' && candSubfieldData.originalValue.match(/<KEEP>/u)) {
+    return true;
+  }
+
+  // Don't add 264$b 'Kustannuspaikka tuntematon' etc
+  if (!valueCarriesMeaning(targetField.tag, candSubfieldData.code, candSubfieldData.normalizedValue)) {
+    return true;
+  }
+
+
+  // Don't add $0 subfields that mean the same even if they look different:
+  const alephIdentifierType = normalizeAs(targetField.tag, candSubfieldData.code);
+  if (alephIdentifierType !== undefined) {
+    const normalizedSubfieldValue = normalizeControlSubfieldValue(candSubfieldData.originalValue, alephIdentifierType);
+    if (targetField.subfields.some(sf => normalizeControlSubfieldValue(sf.value) === normalizedSubfieldValue && sf.code === candSubfieldData.code)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
+function skipNormalizedComparison(tag, subfieldCode, subfieldValue) {
+  if (tag === '020' && subfieldCode === 'a') {
+    return true;
+  }
+  // Hackish: we want 'ntamo' to win 'Ntamo'...
+  // If there are other similar excepting put them into an array.
+  if (['110', '610', '710', '810'].includes(tag) && subfieldCode === 'a' && subfieldValue.substring(0, 5) === 'ntamo') {
+    return true;
+  }
+  return false;
+}
+
+function mergeOrAddSubfieldNotRequired(targetField, candSubfieldData) {
+  if (catalogingSourceModifyingAgencyCandIsOriginalCatalogingSourceAgencyInTargetField(targetField, candSubfieldData) || ennakkotietoInSubfieldG(candSubfieldData)) {
+    return true;
+  }
+
+  if (mergeOrAddSubfieldNotRequiredSpecialCases(targetField, candSubfieldData)) {
+    return true;
+  }
+
+  const relevantTargetSubfields = targetField.subfields.filter(sf => sf.code === candSubfieldData.code);
+  // Target field does not have this subfield yet:
+  if (relevantTargetSubfields.length === 0) {
+    return false;
+  }
+  nvdebug(`     Look for identical subfields in '${fieldToString(targetField)}' using`, debugDev);
+  nvdebug(`      ORIG.    ‡${candSubfieldData.code} ${candSubfieldData.originalValue}`, debugDev);
+  nvdebug(`      NO-PUNC  ‡${candSubfieldData.code} ${candSubfieldData.punctuationlessValue}`, debugDev);
+  if (relevantTargetSubfields.some(sf => sf.code === candSubfieldData.code && sf.value === candSubfieldData.originalValue)) {
+    return true;
+  }
+  if (relevantTargetSubfields.some(sf => sf.code === candSubfieldData.code && sf.value === candSubfieldData.punctuationlessValue)) {
+    return true;
+  }
+
+  if (!skipNormalizedComparison(targetField.tag, candSubfieldData.code, candSubfieldData.originalValue)) {
+    const normalizedTargetField = cloneAndNormalizeFieldForComparison(targetField);
+    nvdebug(`     Look for identical normalized subfields in '${fieldToString(normalizedTargetField)}'`, debugDev);
+    nvdebug(`      NO-PUNC ‡${candSubfieldData.code} ${candSubfieldData.normalizedValue})`, debugDev);
+
+    if (normalizedTargetField.subfields.some(sf => sf.code === candSubfieldData.code && sf.value === candSubfieldData.normalizedValue)) {
+      // Subfield with identical normalized value exists. Do nothing.
+      // Not ideal 382‡n subfields, I guess... Nor 505‡trg repetitions... These need to be fixed...
+      return true;
+    }
+  }
+
+  return false; // (note that this is a double negation: not required is false)
+}
+
+function addSubfield(targetField, candSubfield) {
+  nvdebug(` Added subfield '${subfieldToString(candSubfield)}' to field`, debugDev);
+  // Add subfield to the end of all subfields. NB! Implement a separate function that does this + subfield reordering somehow...
+  targetField.subfields.push(candSubfield); // eslint-disable-line functional/immutable-data
+
+  targetField.merged = 1; // eslint-disable-line functional/immutable-data
+
+  setPunctuationFlag(targetField, candSubfield);
+  sortAdjacentSubfields(targetField);
+
+}
+
+function setPunctuationFlag(field, addedSubfield) {
+  if (isControlSubfieldCode(addedSubfield.code)) { // These are never punctuation related
+    return;
+  }
+  field.useExternalEndPunctuation = 1; // eslint-disable-line functional/immutable-data
+}
+
+
+function resetPaired880(candFieldPair880, targetField, punctlessCandSubfield) {
+  // No relevant:
+  if (punctlessCandSubfield.code !== '6') {
+    return;
+  }
+  if (targetField.tag === '880') {
+    return;
+  }
+  // NB! $6 comes first:
+  if (candFieldPair880 === undefined || !candFieldPair880.subfields || candFieldPair880.subfields[0].code !== '6') {
+    return;
+
+  }
+  nvdebug(`880 contents: ${fieldToString(candFieldPair880)}`, debugDev);
+  resetSubfield6Tag(candFieldPair880.subfields[0], targetField.tag);
+}
+
+export function mergeOrAddSubfield(targetField, candSubfieldData, candFieldPairs880 = []) {
+
+  const candSubfieldAsString = `${candSubfieldData.code} ${candSubfieldData.originalValue}`;
+
+  nvdebug(`   Q: mergeOrAddSubfield '${candSubfieldAsString}'\n      with field '${fieldToString(targetField)}'?`, debugDev);
+  if (mergeOrAddSubfieldNotRequired(targetField, candSubfieldData)) {
+    nvdebug(`    A: No. No need to merge nor to add the subfield '${candSubfieldAsString}'`, debugDev);
+    return;
+  }
+
+  const candSubfield = {'code': candSubfieldData.code, 'value': candSubfieldData.punctuationlessValue};
+
+  // Currently only for X00$d 1984- => 1984-2000 type of changes, where source version is better that what base has.
+  // It all other cases the original subfield is kept.
+  const original = fieldToString(targetField);
+
+  if (mergeSubfield(targetField, candSubfield)) { // We might need the normalizedCandSubfield later on
+    mergeSubfieldPostprocessor();
+    return;
+  }
+
+  // Subfield codes missing from the original record can be added by default:
+  if (addSubfieldWithPreviouslyUnseenSubfieldCode()) {
+    return;
+  }
+
+  // melindaCustomMergeFields.json tells us whether the subfield is repeatable or not:
+  if (subfieldIsRepeatable(targetField.tag, candSubfield.code)) {
+    // We don't want to add multiple, say, 260$c
+    if (['260', '264'].includes(targetField.tag)) {
+      nvdebug(`    A: Exceptionally skip repeatable existing subfield '${subfieldToString(candSubfield)}'`, debugDev);
+      return;
+    }
+    nvdebug(`    A: Yes. Add repeatable subfield '${subfieldToString(candSubfield)}'`, debugDev);
+    targetField.merged = 1; // eslint-disable-line functional/immutable-data
+    setPunctuationFlag(targetField, candSubfield);
+    addSubfield(targetField, candSubfield);
+    return;
+  }
+
+  nvdebug(`    A: No. Non-repeatable subfield '${subfieldToString(candSubfield)}'`, debugDev);
+  return;
+
+  function mergeSubfieldPostprocessor() {
+    if (original !== fieldToString(targetField)) {
+      nvdebug(`    A: Merge. Subfield '${candSubfieldAsString}' replaces the original subfield.`, debugDev);
+      targetField.merged = 1; // eslint-disable-line functional/immutable-data
+      setPunctuationFlag(targetField, candSubfield);
+      return;
+    }
+    nvdebug(`      A: No. Field ${original} already had the same or a synonymous or a better merge candidate than our subfield '${candSubfieldAsString}'.`, debugDev);
+    return;
+  }
+
+  function addSubfieldWithPreviouslyUnseenSubfieldCode() {
+    if (!fieldHasSubfield(targetField, candSubfield.code)) {
+      nvdebug(`    A: Yes. Add previously unseen subfield '${subfieldToString(candSubfield)}'`, debugDev);
+      targetField.merged = 1; // eslint-disable-line functional/immutable-data
+      setPunctuationFlag(targetField, candSubfield);
+      candFieldPairs880.forEach(pair => resetPaired880(pair, targetField, candSubfield));
+      addSubfield(targetField, candSubfield);
+      return true;
+    }
+    return false;
+  }
+}