@natlibfi/marc-record-validators-melinda 11.3.1 → 11.3.2-alpha.2

package/src/merge-fields/mergeSubfield.js

@@ -0,0 +1,306 @@
+import createDebugLogger from 'debug';
+import {partsAgree, subfieldContainsPartData} from '../normalizeSubfieldValueForComparison';
+import {valueCarriesMeaning} from './worldKnowledge';
+import {nvdebug} from '../utils';
+import {tagAndSubfieldCodeReferToIsbn} from '../normalizeFieldForComparison.js';
+import {canContainOptionalQualifier, splitToNameAndQualifier} from './counterpartField';
+
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:mergeSubfield');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+// NB! These are X00 specific. Should we somehow parametrize them?
+const onlyBirthYear = /^[1-9][0-9]*-[,.]?$/u;
+const onlyDeathYear = /^-[1-9][0-9]*[,.]?$/u;
+const birthYearAndDeathYear = /^[1-9][0-9]*-[1-9][0-9]*[,.]?$/u;
+
+function getDeathYear(str) {
+  return parseInt(str.substring(str.indexOf('-') + 1), 10);
+}
+
+function isValidBirthYearAndDeathYear(str) {
+  if (!birthYearAndDeathYear.test(str)) {
+    return false;
+  }
+  // We have two years
+  const b = parseInt(str, 10);
+  const d = getDeathYear(str);
+  if (b > d) { // died before birth! Rather unlikely.
+    return false;
+  }
+  if (d - b > 125) { // Over 125 years old. Rather unlikely.
+    return false;
+  }
+  // Possible sanity check: Died after current year?
+  return true;
+}
+
+function anyYear(str) {
+  if (onlyBirthYear.test(str) || onlyDeathYear.test(str) || isValidBirthYearAndDeathYear(str)) {
+    return true;
+  }
+  return false;
+}
+
+function replaceEntrysBirthAndDeathYear(targetField, candSubfield, relevantSubfields) {
+  if (birthYearAndDeathYear.test(candSubfield.value)) {
+    if (onlyBirthYear.test(relevantSubfields[0].value) && parseInt(relevantSubfields[0].value, 10) === parseInt(candSubfield.value, 10)) {
+      relevantSubfields[0].value = candSubfield.value; // eslint-disable-line functional/immutable-data
+      return true;
+    }
+
+    if (onlyDeathYear.test(relevantSubfields[0].value) && getDeathYear(relevantSubfields[0].value) === getDeathYear(candSubfield.value)) {
+      relevantSubfields[0].value = candSubfield.value; // eslint-disable-line functional/immutable-data
+      return true;
+    }
+  }
+  return false;
+}
+
+function replaceDatesAssociatedWithName(targetField, candSubfield, relevantSubfields) {
+  // Add also the death year, if the original value only contains birth year.
+  // This function treats only with X00$d subfields:
+  if (candSubfield.code !== 'd' || !(/^[1678]00$/u).test(targetField.tag)) { // njsscan-ignore: regex_dos
+    return false;
+  }
+
+  if (!anyYear(relevantSubfields[0].value) && anyYear(candSubfield.value)) {
+    relevantSubfields[0].value = candSubfield.value; // eslint-disable-line functional/immutable-data
+    return true;
+  }
+
+  if (replaceEntrysBirthAndDeathYear(targetField, candSubfield, relevantSubfields)) {
+    return true;
+  }
+  return false;
+}
+
+// use array.includes(value) for easy extendability (Swedish, other languages, abbrs, etc.()
+function isKierreselka(value) {
+  return ['kierreselkä', 'spiral bound', 'spiral-bound', 'spiralrygg'].includes(value);
+}
+
+function isKovakantinen(value) {
+  return ['hardback', 'hardcover', 'hårda pärmar', 'kovakantinen'].includes(value);
+}
+
+function isPehmeakantinen(value) {
+  return ['mjuka pärmar', 'paperback', 'pehmeäkantinen', 'softcover'].includes(value);
+}
+
+function isItsenainenJatkoOsa(value) {
+  if (value.match(/^Fristående fortsättning på verket[^a-z]*$/ui)) {
+    return true;
+  }
+  if (value.match(/^Itsenäinen jatko-osa teokselle[^a-z]*$/ui)) {
+    return true;
+  }
+  return false;
+}
+
+function isSisaltaaTeos(value) {
+  if (value.match(/^Innehåller \(verk\)[^a-z]*$/ui)) {
+    return true;
+  }
+  if (value.match(/^Sisältää \(teos\)[^a-z]*$/ui)) {
+    return true;
+  }
+  return false;
+}
+function relationInformationMatches(candSubfield, relevantSubfields) {
+  if (isSisaltaaTeos(candSubfield.value) && relevantSubfields.some(sf => isSisaltaaTeos(sf.value))) {
+    return true;
+  }
+  if (isItsenainenJatkoOsa(candSubfield.value) && relevantSubfields.some(sf => isItsenainenJatkoOsa(sf.value))) {
+    return true;
+  }
+
+  return false;
+}
+
+function coverTypesMatch(candSubfield, relevantSubfields) {
+  if (isPehmeakantinen(candSubfield.value) && relevantSubfields.some(sf => isPehmeakantinen(sf.value))) {
+    return true;
+  }
+  if (isKovakantinen(candSubfield.value) && relevantSubfields.some(sf => isKovakantinen(sf.value))) {
+    return true;
+  }
+  if (isKierreselka(candSubfield.value) && relevantSubfields.some(sf => isKierreselka(sf.value))) {
+    return true;
+  }
+  return false;
+}
+
+function httpToHttps(val) {
+  return val.replace(/http:\/\//ug, 'https://');
+}
+
+function pairHttpAndHttps(candSubfield, relevantSubfields) {
+  const a = httpToHttps(candSubfield.value);
+  const bs = relevantSubfields.map(sf => httpToHttps(sf.value));
+  return bs.includes(a);
+}
+
+function isSynonym(field, candSubfield, relevantSubfields) {
+  if (candSubfield.code === 'q' && ['015', '020', '024', '028'].includes(field.tag)) {
+    return coverTypesMatch(candSubfield, relevantSubfields);
+  }
+
+  //nvdebug(`Looking for synonyms for '${subfieldToString(candSubfield)}'...`, debugDev);
+
+  if (relationInformationMatches(candSubfield, relevantSubfields)) {
+    return true;
+  }
+
+  if (pairHttpAndHttps(candSubfield, relevantSubfields)) {
+    return true;
+  }
+
+  return false;
+}
+
+function preferHyphenatedISBN(field, candSubfield, relevantSubfields) {
+  if (!tagAndSubfieldCodeReferToIsbn(field.tag, candSubfield.code) || candSubfield.value.includes('-') === -1) {
+    return false;
+  }
+
+  // Must not already exist:
+  if (relevantSubfields.some(sf => sf.value === candSubfield.value)) {
+    return false;
+  }
+
+  const hyphenlessSubfields = relevantSubfields.filter(sf => sf.value.includes('-') > -1);
+  const pair = hyphenlessSubfields.find(sf => sf.value === candSubfield.value.replace(/-/gu, ''));
+  if (!pair) {
+    return false;
+  }
+  pair.value = candSubfield.value; // eslint-disable-line functional/immutable-data
+  return true;
+}
+
+function preferHttpsOverHttp(candSubfield, relevantSubfields) {
+  if (candSubfield.value.substring(0, 8) !== 'https://') {
+    return false;
+  }
+
+  const httpVersion = `http://${candSubfield.value.substring(8)}`;
+  const pair = relevantSubfields.find(sf => sf.value === httpVersion);
+
+  if (!pair) {
+    return false;
+  }
+  pair.value = candSubfield.value; // eslint-disable-line functional/immutable-data
+  return true;
+}
+
+
+function preferQualifierVersion(field, candSubfield, relevantSubfields) {
+  if (!canContainOptionalQualifier(field.tag, candSubfield.code)) { // currently only 300$a and 776$i can prefer source...
+    return false;
+  }
+
+  const [name1, qualifier1] = splitToNameAndQualifier(candSubfield.value);
+  const pair = relevantSubfields.find(sf => subfieldQualifierCheck(sf, name1, qualifier1));
+  if (!pair) {
+    return false;
+  }
+  // SN: "Kuvailuohjeiden näkökulmasta epubille ei pitäisi koskaan merkitä sivumäärää"
+  if (field.tag === '300' && candSubfield.code === 'a' && candSubfield.value.match(/(?:online|verkko)/iu)) {
+    return true; // True, but don't prefer the source value
+  }
+
+  pair.value = candSubfield.value; // eslint-disable-line functional/immutable-data
+  return true;
+
+  function subfieldQualifierCheck(subfield, name, qualifier) {
+    const [name2, qualifier2] = splitToNameAndQualifier(candSubfield.value);
+    if (name !== name2) {
+      return false;
+    }
+    if (!qualifier || !qualifier2 || qualifier === qualifier2) {
+      return true;
+    }
+    return false;
+  }
+
+}
+
+function preferSourceCorporateName(field, candSubfield, pair) {
+  if (candSubfield.code !== 'a' || !['110', '610', '710', '810'].includes(field.tag)) {
+    return false;
+  }
+  nvdebug(`CORP base '${pair.value}' vs '${candSubfield.value}'`, debugDev);
+  const prefer = actualPrefenceCheck();
+  if (prefer) {
+    pair.value = candSubfield.value; // eslint-disable-line functional/immutable-data
+    return true;
+  }
+  return false;
+
+  function actualPrefenceCheck() {
+    if (candSubfield.value.match(/^Werner Söderström/u) && pair.value.match(/^WSOY/ui)) {
+      return true;
+    }
+    if (candSubfield.value.match(/^ntamo/u) && pair.value.match(/^N(?:tamo|TAMO)/u)) {
+      return true;
+    }
+    // Prefer (qualifier):
+    const [sourceName, sourceQualifier] = splitToNameAndQualifier(candSubfield.value);
+    const [baseName, baseQualifier] = splitToNameAndQualifier(pair.value);
+    if (sourceName === baseName && baseQualifier === undefined && sourceQualifier !== undefined) {
+      return true;
+    }
+    // Not taking prefix and suffix into account here...
+    return false;
+  }
+
+}
+
+export function mergeSubfield(targetField, candSubfield) {
+  // Replace existing subfield with the incoming field. These replacements are by name rather hacky...
+  // Currenty we only select the better X00$d.
+  // In future we might do more things here. Examples:
+  // - "FOO" gets replaced by "Foo" in certain fields.
+  // - "Etunimi Sukunimi" might lose to "Sukunimi, Etunimi" in X00 fields.
+  // - [put your ideas here]
+  // Return true, if replace is done.
+  // However, replacing/succeeding requires a sanity check, that the new value is a better one...
+  // Thus, typically this function fails...
+
+  const relevantSubfields = targetField.subfields.filter(subfield => subfield.code === candSubfield.code);
+
+  // There's nothing to replace the incoming subfield with. Thus abort:
+  if (relevantSubfields.length === 0) {
+    return false;
+  }
+
+  nvdebug(`Got ${relevantSubfields.length} sf-cand(s) for field ${targetField.tag}‡${candSubfield.code}`, debugDev);
+
+
+  if (replaceDatesAssociatedWithName(targetField, candSubfield, relevantSubfields) ||
+      preferHyphenatedISBN(targetField, candSubfield, relevantSubfields) ||
+      preferHttpsOverHttp(candSubfield, relevantSubfields) ||
+      preferSourceCorporateName(targetField, candSubfield, relevantSubfields[0]) || // SF is non-repeat
+      preferQualifierVersion(targetField, candSubfield, relevantSubfields) ||
+      isSynonym(targetField, candSubfield, relevantSubfields)) {
+    return true;
+  }
+
+  // We found a crappy empty subfield: replace that with a meaningful one.
+  // 260 $a value "[S.l]" is the main type for this.
+  const meaninglessSubfields = relevantSubfields.filter(sf => !valueCarriesMeaning(targetField.tag, sf.code, sf.value));
+  if (meaninglessSubfields.length > 0) {
+    meaninglessSubfields[0].value = candSubfield.value; // eslint-disable-line functional/immutable-data
+    return true;
+  }
+
+  // Mark 490$v "osa 1" vs "1" as merged (2nd part of MET-53).
+  // NB! Keeps the original value and drops the incoming value. (Just preventing it from going to add-part...)
+  // NB! We could improve this and choose the longer value later on.
+  if (subfieldContainsPartData(targetField.tag, candSubfield.code)) {
+    if (relevantSubfields.some(sf => partsAgree(sf.value, candSubfield.value, targetField.tag, candSubfield.code))) {
+      return true;
+    }
+  }
+  return false; // default to failure
+}

package/src/merge-fields/removeDuplicateSubfields.js

@@ -0,0 +1,50 @@
+
+import {nvdebug, subfieldToString} from '../utils.js';
+import createDebugLogger from 'debug';
+import {cloneAndRemovePunctuation} from '../normalizeFieldForComparison.js';
+import {sortAdjacentSubfields} from '../sortSubfields';
+import {fieldFixPunctuation} from '../punctuation2';
+
+
+// NB This should be moved and converted to a validator/fixer as well...
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:merge-fields:removeDuplicateSubfields');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+export function recordRemoveDuplicateSubfieldsFromFields(record) {
+  record.fields.forEach(field => fieldRemoveDuplicateSubfields(field));
+}
+
+export function fieldRemoveDuplicateSubfields(field) {
+  // Skip bad (382, 505) and risky (264 ...) stuff: 382$n, 505$r, others...
+  if (!field.subfields || ['264', '300', '382', '505'].includes(field.tag)) {
+    return;
+  }
+
+  const strippedField = cloneAndRemovePunctuation(field); // make punctuation-less version
+  /* eslint-disable */
+  let seen = {};
+
+  field.subfields = field.subfields.filter((sf, i) => notSeenBefore(sf, i));
+
+  if (field.collapsed) {
+    sortAdjacentSubfields(field);
+    fieldFixPunctuation(field);
+    delete field.collapsed;
+  }
+
+
+  function notSeenBefore(sf, index) {
+    const subfieldAsString = subfieldToString(strippedField.subfields[index]); // use normalized form
+    if (seen[subfieldAsString]) {
+      nvdebug(`Remove field-internal duplicate subfield ${subfieldToString(sf)}`, debugDev);
+      field.collapsed = 1; // trigger punctuation reset
+      return false;
+    }
+    //nvdebug(`identical subfield removal: Add ${subfieldAsString} to seen[]`, debugDev);
+    seen[subfieldAsString] = subfieldAsString;
+    return true;
+  }
+  /* eslint-enable */
+
+}

package/src/merge-fields/worldKnowledge.js

@@ -0,0 +1,104 @@
+//import {nvdebug} from '../utils';
+
+export function valueCarriesMeaning(tag, subfieldCode, value) {
+  // Some data is pretty meaningless and as meaningless is pretty close to nothing, this meaningless data should no prevent merge.
+  // The list below is incomples (swedish translations etc)
+  if (tag === '260' || tag === '264') {
+    // We drop these, instead of normalizing, as KV does not put this information in place...
+    if (subfieldCode === 'a') {
+      if (value.match(/^[^a-z]*(?:Kustannuspaikka tuntematon|S\.l)[^a-z]*$/ui)) {
+        return false;
+      }
+    }
+    if (subfieldCode === 'b') {
+      if (value.match(/^[^a-z]*(?:Kustantaja tuntematon|S\.n)[^a-z]*$/ui)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return true;
+}
+
+export function normalizeForSamenessCheck(tag, subfieldCode, originalValue) {
+  // NB! These work only for non-repeatable subfields!
+  // Repeatable subfields are currently handled in mergeSubfields.js. Only non-repeatable subfields block field merge,
+  // (This split is suboptiomal... Minimum fix: make this disctinction cleaner...)
+  if (subfieldCode === 'a' && ['100', '600', '700', '800'].includes(tag)) {
+    return normalizePersonalName(originalValue);
+  }
+
+  // NB! originalValue should already be lowercased, stripped on initial '[' chars and postpunctuation.
+  if (tag === '250' && subfieldCode === 'a') {
+    return normalizeEditionStatement(originalValue);
+  }
+
+  // 506 - Restrictions on Access Note (R), $a - Terms governing access (NR)
+  if (tag === '506' && subfieldCode === 'a') {
+    return normalize506a(originalValue);
+  }
+
+  if (tag === '534' && subfieldCode === 'p') {
+    return normalizeOriginalVersionNoteIntroductoryPhrase(originalValue);
+  }
+
+  return originalValue;
+}
+
+
+function normalizePersonalName(originalValue) {
+  // Use more readable "Forename Surname" format in comparisons:
+  return originalValue.replace(/^([^,]+), ([^,]+)$/u, '$2 $1'); // eslint-disable-line prefer-named-capture-group
+}
+
+const sallittu506a = ['sallittu kaikenikäisille', 'sallittu', 's']; // downcased, without punctuation
+function normalize506a(originalValue) {
+  if (sallittu506a.includes(originalValue)) {
+    return sallittu506a[0];
+  }
+  return originalValue;
+}
+
+const introductoryPhrasesMeaning1 = ['alkuperäinen', 'alkuperäisen julkaisutiedot', 'alun perin julkaistu', 'alunperin julkaistu'];
+function normalizeOriginalVersionNoteIntroductoryPhrase(originalValue) {
+  // MELKEHITYS-1935-ish:
+  if (introductoryPhrasesMeaning1.includes(originalValue)) {
+    return introductoryPhrasesMeaning1[0];
+  }
+
+  return originalValue;
+}
+
+function normalizeEditionStatement(originalValue) {
+  const value = originalValue;
+
+  // As normalization tries to translate things info Finnish, use this for similarity check only!
+  if (value.match(/^[1-9][0-9]*(?:\.|:a|nd|rd|st|th) (?:ed\.?|edition|p\.?|painos|uppl\.?|upplagan)[.\]]*$/ui)) {
+    const nth = value.replace(/[^0-9].*$/u, '');
+    return `${nth}. painos`;
+  }
+
+  // Quick and dirty fix for
+  if (value.match(/^[1-9][0-9]*(?:\.|:a|nd|rd|st|th)(?: förnyade|,? rev\.| uud\.| uudistettu) (?:ed\.?|edition|p\.?|painos|uppl\.?|upplagan)[.\]]*$/ui)) {
+    const nth = value.replace(/[^0-9].*$/u, '');
+    return `${nth}. uudistettu painos`;
+  }
+
+  if (value.match(/^(?:First|Första|Ensimmäinen) (?:ed\.?|edition|p\.?|painos|uppl\.?|upplagan)[.\]]*$/ui)) {
+    return `1. painos`;
+  }
+
+  if (value.match(/^(?:Andra|Second|Toinen) (?:ed\.?|edition|p\.?|painos|uppl\.?|upplagan)[.\]]*$/ui)) {
+    return `2. painos`;
+  }
+
+  if (value.match(/^(?:Kolmas|Third|Tredje) (?:ed\.?|edition|p\.?|painos|uppl\.?|upplagan)[.\]]*$/ui)) {
+    return `3. painos`;
+  }
+
+  if (value.match(/^(?:Fourth|Fjärde|Neljäs) (?:ed\.?|edition|p\.?|painos|uppl\.?|upplagan)[.\]]*$/ui)) {
+    return `4. painos`;
+  }
+
+  return originalValue;
+}

package/src/merge-fields.spec.js

@@ -0,0 +1,52 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './merge-fields/';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import createDebugLogger from 'debug';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'merge-fields'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/merge-field:test');
+
+async function testValidatorFactory() {
+  const validator = await validatorFactory();
+
+  expect(validator)
+    .to.be.an('object')
+    .that.has.any.keys('description', 'validate');
+
+  expect(validator.description).to.be.a('string');
+  expect(validator.validate).to.be.a('function');
+}
+
+async function callback({getFixture, enabled = true, fix = false}) {
+  if (enabled === false) {
+    debug('TEST SKIPPED!');
+    return;
+  }
+
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    expect(result).to.eql(expectedResult);
+    return;
+  }
+
+  await validator.fix(record);
+  expect(record).to.eql(expectedResult);
+}

package/src/subfield6Utils.js

@@ -1,9 +1,13 @@
-// import createDebugLogger from 'debug';
+import createDebugLogger from 'debug';
 // const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield6Utils');
 
 import {add8s, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, isValidSubfield8} from './subfield8Utils';
 import {fieldHasSubfield, fieldToString, fieldsToString, nvdebug, subfieldToString} from './utils';
 
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:subfield6Utils');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
 // NB! Subfield 6 is non-repeatable and it should always comes first!
 // NB! Index size should always be 2 (preceding 0 required for 01..09) However, support for 100+ was added on 2023-02-27.
 // NB! Index value '00' are left as they are (is not paired/indexed/whatever.
@@ -483,3 +487,12 @@ export function get6s(field, candidateFields) { // NB! Convert field to fields!!
   return relevantFields;
 }
 
+export function resetSubfield6Tag(subfield, tag) {
+  if (!isValidSubfield6(subfield)) {
+    return;
+  }
+  // NB! mainly for 1XX<->7XX transfers
+  const newValue = `${tag}-${subfield.value.substring(4)}`;
+  nvdebug(`Set subfield $6 value from ${subfieldToString(subfield)} to ${newValue}`, debugDev);
+  subfield.value = newValue; // eslint-disable-line functional/immutable-data
+}

package/src/utils.js

@@ -1,3 +1,15 @@
+import createDebugLogger from 'debug';
+
+import fs from 'fs';
+import path from 'path';
+
+const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:utils');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+const melindaFields = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'src', 'melindaCustomMergeFields.json'), 'utf8'));
+
+
 export function isElectronicMaterial(record) {
   const f337s = record.get('337');
 
@@ -112,3 +124,110 @@ export function getCatalogingLanguage(record, defaultCatalogingLanguage = undefi
 export function uniqArray(arr) {
   return arr.filter((val, i) => arr.indexOf(val) === i);
 }
+
+export function fieldsAreIdentical(field1, field2) {
+  if (field1.tag !== field2.tag) { // NB! We are skipping normalizations here on purpose! They should be done beforehand...
+    return false;
+  }
+  return fieldToString(field1) === fieldToString(field2);
+
+  // The order of subfields is relevant! Bloody JS idiotisms make people use conditions such as:
+  // return field1.subfields.every(sf => field2.subfields.some(sf2 => sf.code === sf2.code && sf.value === sf2.value));
+}
+
+export function fieldHasNSubfields(field, subfieldCode/*, subfieldValue = null*/) {
+  const relevantSubfields = field.subfields.filter(sf => sf.code === subfieldCode);
+  //if (subfieldValue === null) {
+  return relevantSubfields.length;
+  //}
+  //const subset = relevantSubfields.filter(value => value === subfieldValue);
+  //return subset.length;
+}
+
+export function removeCopyright(value) {
+  return value.replace(/^(?:c|p|©|℗|Cop\. ?) ?((?:1[0-9][0-9][0-9]|20[012][0-9])\.?)$/ui, '$1'); // eslint-disable-line prefer-named-capture-group
+}
+
+function isNonStandardNonrepeatableSubfield(tag, subfieldCode) {
+  // Put these into config or so...
+  if (tag === '264') {
+    return ['a', 'b', 'c'].includes(subfieldCode);
+  }
+
+  if (['336', '337', '338'].includes(tag)) {
+    return ['a', 'b', '2'].includes(subfieldCode);
+  }
+
+  return false;
+}
+
+
+export function subfieldIsRepeatable(tag, subfieldCode) {
+
+  if (isNonStandardNonrepeatableSubfield(tag, subfieldCode)) {
+    return false;
+  }
+
+  // These we know or "know":
+  // NB! $5 is (according to MARC21 format) non-repeatable, and not usable in all fields, but Melinda has a local exception to this, see MET-300
+  if ('0159'.indexOf(subfieldCode) > -1) {
+    // Uh, can $0 appear on any field?
+    return true;
+  }
+
+  const fieldSpecs = melindaFields.fields.filter(field => field.tag === tag);
+  if (fieldSpecs.length !== 1) {
+    nvdebug(` WARNING! Getting field ${tag} data failed! ${fieldSpecs.length} hits. Default value true is used for'${subfieldCode}' .`, debugDev);
+    return true;
+  }
+
+  const subfieldSpecs = fieldSpecs[0].subfields.filter(subfield => subfield.code === subfieldCode);
+  // Currently we don't support multiple $6 fields due to re-indexing limitations...
+  // Well, $6 is non-repeatable, isn't it?!?
+  // (This might actually already be fixed... Marginal issue, but check eventually.)
+  if (subfieldSpecs.length !== 1 || subfieldCode === '6') {
+    return false; // repeatable if not specified, I guess. Maybe add log or warn?
+  }
+  return subfieldSpecs[0].repeatable;
+}
+
+function marc21GetTagsLegalIndicators(tag) {
+  const fieldSpecs = melindaFields.fields.filter(field => field.tag === tag);
+  if (fieldSpecs.length === 0) {
+    return undefined;
+  }
+  return fieldSpecs[0].indicators;
+}
+
+export function marc21GetTagsLegalInd1Value(tag) {
+  const indicator = marc21GetTagsLegalIndicators(tag);
+  if (indicator === undefined) {
+    return undefined;
+  }
+  return indicator.ind1;
+}
+
+export function marc21GetTagsLegalInd2Value(tag) {
+  const indicator = marc21GetTagsLegalIndicators(tag);
+  if (indicator === undefined) {
+    return undefined;
+  }
+  return indicator.ind2;
+}
+
+export function nvdebugSubfieldArray(subfields, prefix = '  ', func = undefined) {
+  subfields.forEach(subfield => nvdebug(`${prefix}${subfieldToString(subfield)}`, func));
+}
+
+export function subfieldsAreIdentical(subfieldA, subfieldB) {
+  return subfieldA.code === subfieldB.code && subfieldA.value === subfieldB.value;
+}
+
+export function fieldHasMultipleSubfields(field, subfieldCode/*, subfieldValue = null*/) {
+  return fieldHasNSubfields(field, subfieldCode) > 1;
+}
+
+export function hasCopyright(value) {
+  const modValue = removeCopyright(value);
+  return value !== modValue;
+}

package/test-fixtures/merge-fields/f01/expectedResult.json

@@ -0,0 +1,11 @@
+{
+  "_validationOptions": {},
+  "leader": "12345cam a22123454i 4500",
+  "fields": [
+    { "tag": "700", "ind1": "1", "ind2": " ", "subfields": [
+      { "code": "a", "value": "Sukunimi, Etunimi," },
+      { "code": "e", "value": "säveltäjä," },
+      { "code": "e", "value": "sovittaja." }
+    ]}
+  ]
+}

package/test-fixtures/merge-fields/f01/metadata.json

@@ -0,0 +1,5 @@
+{
+  "description": "Fix: merge two 700 fields",
+  "only": false,
+  "fix": true
+}