@natlibfi/marc-record-validators-melinda 11.0.0-alpha.1 → 11.1.0-alpha.1

package/src/fix-33X.js

@@ -0,0 +1,473 @@
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+import {fieldToString, getCatalogingLanguage, nvdebug} from './utils';
+import {map336CodeToTerm, map337CodeToTerm, map338CodeToTerm} from './field33XUtils';
+
+const description = 'Fix non-RDA 33X field(s)';
+
+
+const map336 = {
+  'Bild (kartografisk ; att vidra)': 'crt',
+  'Bild (kartografisk ; rörlig)': 'crm',
+  'Bild (kartografisk)': 'cri',
+  'Bild (rörlig ; tredimensionell)': 'tdm',
+  'Bild (rörlig ; tvådimensionell)': 'tdi',
+  'Bild (still ; att vidra)': 'tci',
+  'Bild (still ; tredimensionell)': 'sti',
+  'Bild (still)': 'sti',
+  'Data': 'cod',
+  'Data (kartografinen)': 'crd',
+  'Dataset': 'cod',
+  'Dataset (kartografisk)': 'crd',
+  'Datorprogram': 'cop',
+  'Esine': 'tdf',
+  'Esine (kartografinen ; kosketeltava)': 'crn',
+  'Esine (kartografinen)': 'crf',
+  'Esine (kartogragrafinen ; kolmiulotteinen)': 'crf',
+  'Esine (kolmiulotteinen)': 'tdf',
+  'Esine (kosketeltava)': 'tcf',
+  'Flera innehållstyper': 'zzz',
+  'Föremal': 'tdf',
+  'Föremål (att vidra)': 'tcf',
+  'Föremål (kartografisk ; att vidra)': 'crn',
+  'Föremål (kartografisk ; tredimensionell)': 'crn',
+  'Föremål (tredimensionell)': 'tdf',
+  'Geräusche': 'snd',
+  'Kuva': 'sti',
+  'Kuva (kartografinen ; kosketeltava)': 'crt',
+  'Kuva (kartografinen ; liikkuva)': 'crm',
+  'Kuva (kartografinen)': 'cri',
+  'Kuva (liikkuva ; kaksiulotteinen)': 'tdi',
+  'Kuva (liikkuva ; kolmiulotteinen)': 'tdm',
+  'Kuva (still ; kaksiulotteinen)': 'sti',
+  'Kuva (still ; kolmiulotteinen)': 'sti',
+  'Kuva (still ; kosketeltava)': 'tci',
+  'Kuva (still)': 'sti',
+  'Liike (kosketeltava ; notatoitu)': 'tcn',
+  'Liike (notatoitu ; kosketeltava': 'tcn',
+  'Liike (notatoitu)': 'ntv',
+  'Ljud': 'snd',
+  'Musiikki (esitetty)': 'prm',
+  'Musiikki (kosketeltava ; notatoitu)': 'tcm',
+  'Musiikki (notatoitu ; kosketeltava)': 'tcm',
+  'Musiikki (notatoitu)': 'ntm',
+  'Musik (notation ; att vidra)': 'tcm',
+  'Musik (notation)': 'ntm',
+  'Musik (performance)': 'prm',
+  'Määrittelemätön': 'zzz',
+  'Määrittelemätön sisältötyyppi': 'zzz',
+  'Obestämd innehållstyp': 'zzz',
+  'Ospecificerad innehållstyp': 'zzz',
+  'Puhe': 'spw',
+  'Rörelse (notation ; att vidra)': 'tcn',
+  'Rörelse (notation)': 'ntv',
+  'Tal': 'spw',
+  'Teksti': 'txt',
+  'Teksti (kosketeltava); Text (att vidra)': 'tct',
+  'Text': 'txt',
+  'Tietokoneohjelma': 'cop',
+  'Useita sisältötyyppejä': 'zzz',
+  'Vild (still ; tvådimensionell)': 'sti',
+  'annan': 'xxx',
+  'cartographic dataset': 'crd',
+  'cartographic image': 'cri',
+  'cartographic moving image': 'crm',
+  'cartographic tactile image': 'crt',
+  'cartographic tactile three-dimensional form': 'crn',
+  'cartographic three-dimensional form': 'crf',
+  'cartographic three-dimensional tactile form': 'crn',
+  'computer dataset': 'cod',
+  'computer program': 'cop',
+  'dataset': 'cod',
+  'datorprogram': 'cop',
+  'digitaalinen data': 'cod',
+  'digitalt dataset': 'cod',
+  'esitetty musiikki': 'prm',
+  'framförd musik': 'prm',
+  'gesprochenes Wort': 'spw',
+  'kaksiulotteinen liikkuva kuva': 'tdi',
+  'kartografinen data': 'crd',
+  'kartografinen kolmiulotteinen muoto': 'crf',
+  'kartografinen kuva': 'cri',
+  'kartografinen liikkuva kuva': 'crm',
+  'kartografinen taktiili kolmiulotteinen muoto': 'crn',
+  'kartografinen taktiili kuva': 'crt',
+  'kartografisk bild': 'cri',
+  'kartografisk data': 'crd',
+  'kartografisk rörlig bild': 'crm',
+  'kartografisk taktil bild': 'crt',
+  'kartografisk taktil tredimensionell form': 'crn',
+  'kartografisk tredimensionell form': 'crf',
+  'kolmiulotteinen liikkuva kuva': 'tdm',
+  'kolmiulotteinen muoto': 'tdf',
+  'liikenotaatio': 'ntv',
+  'ljud': 'snd',
+  'muu': 'xxx',
+  'määrittelemätön': 'zzz',
+  'notated movement': 'ntv',
+  'notated music': 'ntm',
+  'noterad musik': 'ntm',
+  'nuottikirjoitus': 'ntm',
+  'ospecificerad': 'zzz',
+  'other': 'xxx',
+  'performed music': 'prm',
+  'puhe': 'spw',
+  'rörelsenotation': 'ntv',
+  'sounds': 'snd',
+  'spoken word': 'spw',
+  'still image': 'sti',
+  'stillbild': 'sti',
+  'stillkuva': 'sti',
+  'tactile image': 'tci',
+  'tactile notated movement': 'tcn',
+  'tactile notated music': 'tcm',
+  'tactile text': 'tct',
+  'tactile three-dimensional form': 'tcf',
+  'taktiili kolmiulotteinen muoto': 'tcf',
+  'taktiili kuva': 'tci',
+  'taktiili liikenotaatio': 'tcn',
+  'taktiili nuottikirjoitus': 'tcm',
+  'taktiili teksti': 'tct',
+  'taktil bild': 'tci',
+  'taktil musiknotation': 'tcm',
+  'taktil noterad rörelse': 'tcn',
+  'taktil text': 'tct',
+  'taktil tredimensionell form': 'tcf',
+  'tal': 'spw',
+  'teksti': 'txt',
+  'text': 'txt',
+  'texte': 'txt',
+  'texte tactile': 'tct',
+  'three-dimensional form': 'tdf',
+  'three-dimensional moving image': 'tdm',
+  'tietokoneohjelma': 'cop',
+  'tredimensionell form': 'tdf',
+  'tredimensionell rörlig bild': 'tdm',
+  'tvådimensionell rörlig bild': 'tdi',
+  'two-dimensional moving image': 'tdi',
+  'unbewegtes Bild': 'sti',
+  'unspecified': 'zzz',
+  'Ääni': 'snd',
+  'ääni': 'snd'
+};
+
+const map337 = {
+  'Computermedien': 'c',
+  'Mikroform': 'h',
+  'annan': 'x',
+  'audio': 's',
+  'computer': 'c',
+  'dator': 'c',
+  'datoranvändbar': 'c',
+  'ei välittävää laitetta': 'n',
+  'elektroninen': 'c',
+  'elektronisk': 'c',
+  'heijastettava': 'g',
+  'ingen medietyp': 'n',
+  'käytettävissä ilman laitetta': 'n',
+  'microform': 'h',
+  'microscopic': 'p',
+  'mikroform': 'h',
+  'mikromuoto': 'h',
+  'mikroskooppinen': 'p',
+  'mikroskopisch': 'p',
+  'mikroskopisk': 'p',
+  'muu': 'x',
+  'määrittelemätön': 'z',
+  'määrittelemätön välittävä laite': 'z',
+  'oförmedlad': 'n',
+  'ohne Hilfsmittel zu benutzen': 'n',
+  'omedierad': 'n',
+  'ospecificerad': 'z',
+  'ospecificerad medietyp': 'z',
+  'other': 'x',
+  'projected': 'g',
+  'projektion': 'g',
+  'projicerad': 'g',
+  'projicerbar': 'g',
+  'projizierbar': 'g',
+  'stereografinen': 'e',
+  'stereografisch': 'e',
+  'stereografisk': 'e',
+  'stereographic': 'e',
+  'tietokonekäyttöinen': 'c',
+  'unmediated': 'n',
+  'unspecified': 'z',
+  'useita mediatyyppejä': 'z',
+  'video': 'v',
+  'övrig': 'x'
+};
+
+const map338 = {
+  'aperture card': 'ha',
+  'ark': 'nb',
+  'arkki': 'nb',
+  'audio belt': 'sb',
+  'audio cartridge': 'sg',
+  'audio cylinder': 'se',
+  'audio disc': 'sd',
+  'audio roll': 'sq',
+  'audio wire reel': 'sw',
+  'audiocassette': 'ss',
+  'audiotape reel': 'st',
+  'bildband': 'gf',
+  'bildbandsmagasin': 'gc',
+  'blädderblock': 'nn',
+  'card': 'no',
+  'computer card': 'ck',
+  'computer cartridge': 'cb',
+  'computer disc': 'cd',
+  'computer disc cartridge': 'ce',
+  'computer tape cartridge': 'ca',
+  'computer tape cassette': 'cf',
+  'computer tape reel': 'ch',
+  'datorbandmagasin': 'ca',
+  'datorbandspole': 'ch',
+  'datorkassett': 'cf',
+  'datorkort': 'ck',
+  'datorminnesmodul': 'cb',
+  'datorskiva': 'cd',
+  'datorskivmagasin': 'ce',
+  'dia': 'gs',
+  'diabild': 'gs',
+  'film cartridge': 'mc',
+  'film cassette': 'mf',
+  'film reel': 'mr',
+  'film roll': 'mo',
+  'filmikasetti': 'mf',
+  'filmikela': 'mr',
+  'filmiliuska': 'gd',
+  'filmirulla': 'mo',
+  'filmisilmukkakasetti': 'mc',
+  'filmkassett': 'mf',
+  'filmljudspole': 'si',
+  'filmmagasin': 'mc',
+  'filmremsa': 'gd',
+  'filmrulle': 'mo',
+  'filmslip': 'gd',
+  'filmspole': 'mr',
+  'filmstrip': 'gf',
+  'filmstrip cartridge': 'gc',
+  'flipchart': 'nn',
+  'fönsterkort': 'ha',
+  'föremål': 'nr',
+  'ikkunakortti': 'ha',
+  'kort': 'no',
+  'kortti': 'no',
+  'lehtiötaulu': 'nn',
+  'ljudcylinder': 'se',
+  'ljudkassett': 'ss',
+  'ljudmagasin': 'sg',
+  'ljudrulle': 'sq',
+  'ljudskiva': 'sd',
+  'ljudslinga': 'sb',
+  'ljudspole': 'st',
+  'ljudtråd': 'sw',
+  'microfiche': 'he',
+  'microfiche cassette': 'hf',
+  'microfilm cartridge': 'hb',
+  'microfilm cassette': 'hc',
+  'microfilm reel': 'hd',
+  'microfilm roll': 'hj',
+  'microfilm slip': 'hh',
+  'microopaque': 'hg',
+  'microscope slide': 'pp',
+  'mikrofiche': 'he',
+  'mikrofiche (ogenomskinlig)': 'hg',
+  'mikrofichekassett': 'hf',
+  'mikrofilmikasetti': 'hc',
+  'mikrofilmikela': 'hd',
+  'mikrofilmiliuska': 'hh',
+  'mikrofilmirulla': 'hj',
+  'mikrofilmisilmukkakasetti': 'hb',
+  'mikrofilmskassett': 'hc',
+  'mikrofilmsmagasin': 'hb',
+  'mikrofilmsremsa': 'hh',
+  'mikrofilmsrulle': 'hj',
+  'mikrofilmsspole': 'hd',
+  'mikrokortti': 'he',
+  'mikrokortti (läpinäkymätön)': 'hg',
+  'mikrokorttikasetti': 'hf',
+  'mikroskoperingspreparat': 'pp',
+  'muistikortti': 'ck',
+  'määrittelemätön': 'zu',
+  'nide': 'nc',
+  'object': 'nr',
+  'objekti': 'nr',
+  'online resource': 'cr',
+  'onlineresurs': 'cr',
+  'ospecificerad': 'zu',
+  'overhead transparency': 'gt',
+  'piirikotelo': 'cb',
+  'piirtoheitinkalvo': 'gt',
+  'preparaattilasi': 'pp',
+  'raina': 'gf',
+  'rainakasetti': 'gc',
+  'roll': 'na',
+  'rulla': 'na',
+  'rulle': 'na',
+  'sheet': 'nb',
+  'slide': 'gs',
+  'sound-track reel': 'si',
+  'stereografinen kortti': 'eh',
+  'stereografinen levy': 'es',
+  'stereografisk skiva': 'es',
+  'stereografiskt kort': 'eh',
+  'stereograph card': 'eh',
+  'stereograph disc': 'es',
+  'tietokasetti': 'cf',
+  'tietolevy': 'cd',
+  'tietolevykotelo': 'ce',
+  'tietonauhakela': 'ch',
+  'tietonauhan silmukkakasetti': 'ca',
+  'transparang': 'gt',
+  'unspecified': 'zu',
+  'verkkoaineisto': 'cr',
+  'video cartridge': 'vc',
+  'videocassette': 'vf',
+  'videodisc': 'vd',
+  'videokasetti': 'vf',
+  'videokassett': 'vf',
+  'videokela': 'vr',
+  'videolevy': 'vd',
+  'videomagasin': 'vc',
+  'videosilmukkakasetti': 'vc',
+  'videoskiva': 'vd',
+  'videospole': 'vr',
+  'videotape reel': 'vr',
+  'volume': 'nc',
+  'volym': 'nc',
+  'äänihihna': 'sb',
+  'äänikasetti': 'ss',
+  'äänikela': 'st',
+  'äänilankakela': 'sw',
+  'äänilevy': 'sd',
+  'ääniraitakela': 'si',
+  'äänirulla': 'sq',
+  'äänisilmukkakasetti': 'sg',
+  'äänisylinteri': 'se'
+};
+
+// const multimediaRegexp = /multimedia/ui;
+
+export default function () {
+
+  return {
+    description, validate, fix
+  };
+
+  function fix(record) {
+    nvdebug(`FIX ${description}...`);
+    const catLang = getCatalogingLanguage(record) || 'fin';
+    const fields = getRelevantFields(record);
+    fields.forEach(f => fixField(f, catLang));
+    nvdebug(` GOT ${fields.length}...`);
+    // FFS: we actually need newFields array here! Videogame, for example, might be
+    // 336 ## ‡a kaksiulotteinen liikkuva kuva ‡b tdi ‡2 rdacontent
+    // 336 ## ‡a tietokoneohjelma ‡b cop ‡2 rdacontent
+    const res = {message: [], fix: [], valid: true};
+
+    return res;
+  }
+
+  function validate(record) {
+    nvdebug(`VALIDATE ${description}...`); // NOT READY YET
+    const catLang = getCatalogingLanguage(record) || 'fin';
+    const fields = getRelevantFields(record);
+    if (fields.length === 0) {
+      return {message: [], valid: true};
+    }
+    const originalStrings = fields.map(f => fieldToString(f));
+    const clonedFields = fields.map(f => clone(f));
+    clonedFields.forEach(f => fixField(f, catLang));
+    const modifiedStrings = clonedFields.map(f => fieldToString(f));
+
+    const changes = originalStrings.map((str, i) => `'${str}' => '${modifiedStrings[i]}'`);
+
+    return {message: changes, valid: false};
+  }
+
+
+  function getA(field) {
+    const as = field.subfields.filter(f => f.code === 'a');
+    if (as.length === 1) {
+      return as[0];
+    }
+    return undefined;
+  }
+
+
+  function mapTermToCode(term, tag) {
+    nvdebug(`TERM/${tag}: '${term}'`);
+    if (tag === '336' && term in map336) {
+      return map336[term];
+    }
+    if (tag === '337' && term in map337) {
+      return map337[term];
+    }
+    if (tag === '338' && term in map338) {
+      return map338[term];
+    }
+    return undefined;
+  }
+
+  function mapFieldToCode(field) {
+    const subfieldA = getA(field);
+    if (subfieldA) {
+      return mapTermToCode(subfieldA.value, field.tag);
+    }
+    return undefined;
+  }
+
+  function getRelevantFields(record) {
+    const fields = record.get('33[678]');
+    // Currently not handline $3 etc
+    return fields.filter(f => f.subfields.length === 1 && mapFieldToCode(f));
+  }
+
+  function tagToSubfield2(tag) {
+    if (tag === '336') {
+      return {'code': '2', 'value': 'rdacontent'};
+    }
+    if (tag === '337') {
+      return {'code': '2', 'value': 'rdamedia'};
+    }
+    if (tag === '338') {
+      return {'code': '2', 'value': 'rdacarrier'};
+    }
+  }
+
+  function fixField(field, catalogingLanguage = 'fin') {
+    const subfieldA = getA(field);
+    if (!subfieldA) {
+      return;
+    }
+    const code = mapTermToCode(subfieldA.value, field.tag);
+    if (!code) {
+      return;
+    }
+    const newTerm = codeToTerm(code);
+    if (!newTerm) {
+      return;
+    }
+
+    subfieldA.value = newTerm; // eslint-disable-line functional/immutable-data
+    field.subfields.push({'code': 'b', 'value': code}); // eslint-disable-line functional/immutable-data
+    field.subfields.push(tagToSubfield2(field.tag)); // eslint-disable-line functional/immutable-data
+
+    function codeToTerm(code) {
+      if (field.tag === '336') {
+        return map336CodeToTerm(code, catalogingLanguage);
+      }
+      if (field.tag === '337') {
+        return map337CodeToTerm(code, catalogingLanguage);
+      }
+      if (field.tag === '338') {
+        return map338CodeToTerm(code, catalogingLanguage);
+      }
+      return undefined;
+    }
+  }
+
+}
+

package/src/fix-33X.spec.js

@@ -0,0 +1,46 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './fix-33X';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'fix-33X'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+
+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');
+  expect(validator.fix).to.be.a('function');
+}
+
+async function callback({getFixture, fix = false}) {
+  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/fix-language-codes.js

@@ -0,0 +1,121 @@
+import clone from 'clone';
+import {fieldToString} from './utils';
+// Fix language codes in 008/35-37 and 041 (does not sync them)
+//
+// Author(s): Nicholas Volk
+
+//import createDebugLogger from 'debug';
+//import {fieldToString, nvdebug} from './utils';
+
+const description = 'Fix language codes';
+
+export default function () {
+
+  return {description, validate, fix};
+
+  function fix(record) {
+    //nvdebug(`FIX ME`);
+    const res = {message: [], fix: [], valid: true};
+
+    const [field008] = record.get('008');
+    if (!field008) {
+      return res;
+    }
+
+    fixLanguageField008(field008);
+
+    const f041 = record.get('041');
+    f041.forEach(f => fixField041(f));
+
+    return res;
+  }
+
+
+  function validate(record) {
+    const res = {message: [], valid: true};
+
+    validateField008(record, res);
+
+    const f041 = record.get('041');
+    f041.forEach(f => validateField041(f, res));
+
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+
+  function validateField008(record, res) {
+    const [field008] = record.get('008');
+
+    if (!field008) {
+      return;
+    }
+
+    const originalLanguage = getLanguageFromField008(field008);
+    const modifiedLanguage = deprecatedLanguageToCurrentLanguage(originalLanguage);
+    if (originalLanguage === modifiedLanguage) {
+      return;
+    }
+
+    res.message.push(`Modify 008/35-37: '${originalLanguage}' => '${modifiedLanguage}'`); // eslint-disable-line functional/immutable-data
+    res.valid = false; // eslint-disable-line functional/immutable-data
+  }
+
+
+  function isRelevantField041SubfieldCode(subfield) {
+    return 'abdefghijkmnpqrt'.includes(subfield.code);
+  }
+
+
+  function validateField041(field, res) {
+
+    const clonedField = clone(field);
+    fixField041(clonedField);
+
+    const originalString = fieldToString(field);
+    const modifiedString = fieldToString(clonedField);
+
+    if (originalString === modifiedString) {
+      return;
+    }
+    const msg = `${originalString} => ${modifiedString}`;
+    res.message.push(msg); // eslint-disable-line functional/immutable-data
+
+  }
+
+
+  function fixLanguageField008(field008) {
+    const originalLanguage = getLanguageFromField008(field008);
+    const modifiedLanguage = deprecatedLanguageToCurrentLanguage(originalLanguage);
+    if (originalLanguage !== modifiedLanguage && modifiedLanguage.length === 3) {
+      field008.value = `${field008.value.substring(0, 35)}${modifiedLanguage}${field008.value.substring(38)}`; // eslint-disable-line functional/immutable-data
+      return;
+    }
+  }
+
+  function fixField041(field) {
+    if (field.subfields.some(sf => sf.code === '2')) {
+      return;
+    }
+
+    field.subfields.forEach(sf => fixField041Subfield(sf));
+
+    function fixField041Subfield(subfield) {
+      if (!isRelevantField041SubfieldCode(subfield)) {
+        return;
+      }
+      subfield.value = deprecatedLanguageToCurrentLanguage(subfield.value); // eslint-disable-line functional/immutable-data
+    }
+  }
+
+  function getLanguageFromField008(field) {
+    return field.value.substring(35, 38); // return 008/35-37
+  }
+
+  function deprecatedLanguageToCurrentLanguage(language) {
+    if (language === 'nno' || language === 'nob') { // Nynorsk ja bokmål
+      return 'nor'; // Norwegian
+    }
+    return language;
+  }
+
+}

package/src/fix-language-codes.spec.js

@@ -0,0 +1,45 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './fix-language-codes';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'fix-language-codes'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+
+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, fix = false}) {
+  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/fixRelatorTerms.js

@@ -115,7 +115,7 @@ function subfieldHandleRelatorTermAbbreviation(subfield, language) {
     return;
   }
   nvdebug(`Relator cand subfield: '${subfieldToString(subfield)}', lang: ${language ? language : 'NULL'}`, debugDev);
-  if (language === null || language === 'mul') {
+  if (!language || language === 'mul') {
     subfieldHandleRelatorTermAbbreviation(subfield, 'fin');
     // Maybe later add Swedish here...
     return;