@natlibfi/marc-record-validators-melinda 10.13.0 → 10.13.1-alpha.2

package/package.json

@@ -14,7 +14,7 @@
     "url": "git@github.com:natlibfi/marc-record-validators-melinda.git"
   },
   "license": "MIT",
-  "version": "10.13.0",
+  "version": "10.13.1-alpha.2",
   "main": "./dist/index.js",
   "publishConfig": {
     "access": "public"
@@ -35,35 +35,35 @@
     "build": "babel src --source-maps --copy-files --delete-dir-on-start --out-dir=dist"
   },
   "dependencies": {
-    "@babel/register": "^7.22.5",
+    "@babel/register": "^7.22.15",
     "@natlibfi/issn-verify": "^1.0.3",
     "@natlibfi/marc-record": "^7.3.1",
     "@natlibfi/marc-record-validate": "^8.0.1",
     "cld3-asm": "^3.1.1",
+    "clone": "^2.1.2",
     "debug": "^4.3.4",
-    "isbn3": "^1.1.40",
+    "isbn3": "^1.1.41",
     "langs": "^2.0.0",
     "node-fetch": "^2.7.0",
-    "xml2js": ">=0.6.2 <1.0.0",
-    "clone": "^2.1.2"
+    "xml2js": "^0.6.2"
   },
   "peerDependencies": {
     "@natlibfi/marc-record-validate": "^8.0.1"
   },
   "devDependencies": {
-    "@babel/cli": "^7.22.10",
-    "@babel/core": "^7.22.10",
-    "@babel/eslint-parser": "^7.22.10",
-    "@babel/preset-env": "^7.22.10",
+    "@babel/cli": "^7.22.15",
+    "@babel/core": "^7.22.17",
+    "@babel/eslint-parser": "^7.22.15",
+    "@babel/preset-env": "^7.22.15",
     "@natlibfi/eslint-config-melinda-backend": "^3.0.1",
     "@natlibfi/fixugen": "^2.0.1",
     "@natlibfi/fixura": "^3.0.1",
     "babel-plugin-istanbul": "^6.1.1",
     "babel-plugin-rewire": "^1.2.0",
-    "chai": "^4.3.7",
+    "chai": "^4.3.8",
     "chai-as-promised": "^7.1.1",
     "cross-env": "^7.0.3",
-    "eslint": "^8.47.0",
+    "eslint": "^8.49.0",
     "fetch-mock": "^9.11.0",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0"

package/src/field-505-separators.js

@@ -0,0 +1,75 @@
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+import {fieldToString} from './utils';
+
+// Author(s): Nicholas Volk
+export default function () {
+
+  return {
+    description: 'Normalize " ; " separators as " -- "',
+    validate, fix
+  };
+
+  function fix(record) {
+    record.fields.forEach(field => {
+      fix505(field);
+    });
+
+    const res = {message: [], fix: [], valid: true};
+    return res;
+  }
+
+  function validate(record) {
+    const res = {message: []};
+
+    record.fields?.forEach(field => {
+      validateField(field, res);
+    });
+
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+
+  function validateField(field, res) {
+    const orig = fieldToString(field);
+
+    const normalizedField = fix505(clone(field));
+    const mod = fieldToString(normalizedField);
+    if (orig !== mod) { // Fail as the input is "broken"/"crap"/sumthing
+      res.message.push(`'TODO: ${orig}' => '${mod}'`); // eslint-disable-line functional/immutable-data
+      return;
+    }
+    return;
+  }
+}
+
+
+function field505FixSubfieldA(field) {
+  const a = field.subfields.filter(sf => sf.code === 'a');
+
+  a.forEach(sf => fixSubfieldA(sf));
+
+  function fixSubfieldA(a) {
+    a.value = a.value.replace(/ ; /ug, ' -- '); // eslint-disable-line functional/immutable-data
+  }
+}
+
+function field505FixSubfieldTRG(field) {
+  // Modify subfield if next subfield is $t:
+  const subfieldsThatWillBeModified = field.subfields.filter((sf, i) => i + 1 < field.subfields.length && field.subfields[i + 1].code === 't');
+
+  subfieldsThatWillBeModified.forEach(sf => fixSubfieldThatPrecedesT(sf));
+
+  function fixSubfieldThatPrecedesT(sf) {
+    sf.value = sf.value.replace(/ ;$/u, ' --'); // eslint-disable-line functional/immutable-data
+  }
+}
+
+function fix505(field) {
+  if (field.tag !== '505' || !field.subfields) {
+    return field;
+  }
+  field505FixSubfieldTRG(field);
+  field505FixSubfieldA(field);
+  return field;
+}

package/src/field-505-separators.spec.js

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

@@ -0,0 +1,233 @@
+import clone from 'clone';
+import {fieldFixPunctuation} from './punctuation2';
+import {fieldToString, getCatalogingLanguage, nvdebug, subfieldToString} from './utils';
+import createDebugLogger from 'debug';
+
+// Currently mainly translates X00$e values, so that we don't have "$a Name, $e kirjoittaja, $e författare.".
+// Later on we could try and handle $4 stuff here as well.
+
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:fixRelatorterms');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+export default function () {
+  return {
+    description: 'Fix $e subfields in field [1678][01]0 and 720',
+    validate, fix
+  };
+
+  function fix(record) {
+    const res = {message: [], fix: [], valid: true};
+
+    const language = getCatalogingLanguage(record);
+
+    record.fields.forEach(field => {
+      fieldFixRelatorTerms(field, language, language);
+    });
+
+    return res;
+  }
+
+  function validate(record) {
+    const res = {message: []};
+
+    const language = getCatalogingLanguage(record);
+
+    record.fields.forEach(field => {
+      const clonedField = clone(field);
+      // Rather hackily/abnormally use language as both fromLanguage and toLanguage.
+      // fromLanguage is used to expand "esitt." => "esittäjä".
+      // toLanguage is used by translations (fixes "författere" to "kirjoittaja", if 040$b is "fin")
+      fieldFixRelatorTerms(field, language, language);
+      const clonedFieldAsString = fieldToString(clonedField);
+      const fieldAsString = fieldToString(field);
+      if (fieldAsString !== clonedFieldAsString) { // eslint-disable-line functional/no-conditional-statements
+        res.message.push(`${fieldAsString} => ${clonedFieldAsString}`); // eslint-disable-line functional/immutable-data
+      }
+    });
+
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+}
+
+
+/*
+export default () => (base, source) => {
+  recordTranslateRelatorTerms(base);
+  recordTranslateRelatorTerms(source);
+  recordHandleRelatorTermAbbreviations(base);
+  recordHandleRelatorTermAbbreviations(source);
+  const result = {base, source};
+  return result;
+};
+*/
+
+
+// Partial source: https://marc21.kansalliskirjasto.fi/funktiot_koodit.htm
+// https://wiki.helsinki.fi/display/MARC21svenska/Funktions-+och+relationskoder+-+alfabetiskt+efter+funktion
+// New, better source: https://id.kb.se/find?q=relator&_sort=_sortKeyByLang.en
+
+
+// NB! How to handle German sex-based Verfasser/Verfasserin pairs?
+const relatorTerms = [
+  {'code': 'arr', 'eng': 'arranger', 'fin': 'sovittaja', 'swe': 'arrangör av musikalisk komposition'},
+  {'code': 'art', 'eng': 'artist', 'fin': 'taiteilija', 'swe': 'konstnär'},
+  {'code': 'aui', 'eng': 'author of introduction', 'fin': 'esipuheen tekijä'},
+  {'code': 'aut', 'eng': 'author', 'fin': 'kirjoittaja', 'swe': 'författare'},
+  {'code': 'cmp', 'eng': 'composer', 'fin': 'säveltäjä', 'swe': 'kompositör'},
+  {'code': 'drt', 'eng': 'director', 'fin': 'ohjaaja', 'swe': 'regissör'},
+  {'code': 'edt', 'eng': 'editor', 'fin': 'toimittaja', 'swe': 'redaktör'},
+  {'code': 'ill', 'eng': 'illustrator', 'fin': 'kuvittaja', 'swe': 'illustratör'},
+  {'code': 'lyr', 'eng': 'lyricist', 'fin': 'sanoittaja', 'swe': 'sångtext'},
+  {'code': 'nrt', 'eng': 'narrator', 'fin': 'kertoja', 'swe': 'berättare'}, // berättare/inläsare
+  {'code': 'pbl', 'eng': 'publisher', 'fin': 'julkaisija', 'swe': 'utgivare'},
+  {'code': 'pht', 'eng': 'photographer', 'fin': 'valokuvaaja', 'swe': 'fotograf'},
+  {'code': 'prf', 'eng': 'performer', 'fin': 'esittäjä', 'swe': 'framförande'},
+  {'code': 'pro', 'eng': 'producer', 'fin': 'tuottaja', 'swe': 'producent'},
+  {'code': 'trl', 'eng': 'translator', 'fin': 'kääntäjä', 'swe': 'översättare'}
+];
+
+/*
+function recordNormalizeRelatorTerms(record, defaultLanguageCode = undef) {
+  const languageCode = defaultLanguageCode ? defaultLanguageCode : getCatalogingLanguage(record);
+  if  (!languageCode || ['eng', 'fin', 'swe'].includes(languageCode)) {
+    return;
+  }
+
+}
+*/
+
+
+const finnishAbbreviations = {
+  'esitt.': 'esittäjä',
+  'käänt.': 'kääntäjä',
+  'näytt.': 'näyttelijä',
+  'san.': 'sanoittaja',
+  'sov.': 'sovittaja',
+  'säv.': 'säveltäjä',
+  'toim.': 'toimittaja'
+};
+
+function subfieldHandleRelatorTermAbbreviation(subfield, language) {
+  if (subfield.code !== 'e') {
+    return;
+  }
+  nvdebug(`Relator cand subfield: '${subfieldToString(subfield)}', lang: ${language ? language : 'NULL'}`, debugDev);
+  if (language === null || language === 'mul') {
+    subfieldHandleRelatorTermAbbreviation(subfield, 'fin');
+    // Maybe later add Swedish here...
+    return;
+  }
+  const value = subfield.value.replace(/,$/u, '');
+  const punc = value === subfield.value ? '' : ',';
+
+  const lcValue = value.toLowerCase(); // Check Å, Ä, Ö...
+
+  // NB: Policy: if no language or multi-language: apply all rules! (Not much overlap I hope...)
+  if (language === 'fin') {
+    nvdebug(`Relator try Finnish for '${lcValue}}'...`, debugDev);
+    if (lcValue in finnishAbbreviations) {
+      const hit = `${finnishAbbreviations[lcValue]}${punc}`;
+      nvdebug(`Relator hit: ${hit}`, debugDev);
+      // NB! 'esitt.' => 'esittäjä'
+      subfield.value = hit; // eslint-disable-line functional/immutable-data
+      return;
+    }
+  }
+}
+
+
+function isRelatorField(field) {
+  // Tag list might be incomplete!
+  return field.tag.match(/^(?:100|110|600|610|700|710|720|800|810)$/u);
+}
+
+function fieldHandleRelatorTermAbbreviations(field, language) {
+  if (!isRelatorField(field)) {
+    return;
+  }
+
+  const originalValue = fieldToString(field);
+  field.subfields.forEach(sf => subfieldHandleRelatorTermAbbreviation(sf, language));
+  const modifiedValue = fieldToString(field);
+  if (modifiedValue === originalValue) {
+    return;
+  }
+  // Changes have happened... Try to punctuate.
+  // (NB! We need punctuation as a module, if we are to make abbr expansion a marc-record-validators-melinda validator/fixer)
+  fieldFixPunctuation(field);
+}
+
+function termIsInGivenLanguage(term, language) {
+  return relatorTerms.some(row => language in row && row[language] === term);
+}
+
+function anyToLanguage(originalTerm) {
+  // Sometimes there's no 040$b or 040$b and, say, 040$b and 700$e value don't correlate
+  if (termIsInGivenLanguage(originalTerm, 'fin')) {
+    return 'fin';
+  }
+  if (termIsInGivenLanguage(originalTerm, 'swe')) {
+    return 'swe';
+  }
+  if (termIsInGivenLanguage(originalTerm, 'eng')) {
+    return 'eng';
+  }
+  return null;
+}
+
+function translateRelatorTerm(originalTerm, defaultFromLanguage, toLanguage) {
+
+  // originalTerm is supposed to be normal version (abbrs have been expanded), possibly with punctuation
+  const term = originalTerm.replace(/[,.]$/u, '');
+  nvdebug(`Try to translate '${term}' from ${defaultFromLanguage} to ${toLanguage}`, debugDev);
+
+  // Kind of hacky... If term is in toLanguage, do nothing. defaultFromLanguage (040$b) isn't that reliable.
+  if (termIsInGivenLanguage(term, toLanguage)) {
+    return originalTerm;
+  }
+  // defaultFomLanguage (typically 040$b) isn't that reliable:
+  const fromLanguage = defaultFromLanguage === null || !termIsInGivenLanguage(term, defaultFromLanguage) ? anyToLanguage(term) : defaultFromLanguage;
+
+  const [candRow] = relatorTerms.filter(row => fromLanguage in row && toLanguage in row && row[fromLanguage] === term);
+  if (candRow) {
+    const punc = term === originalTerm ? '' : originalTerm.slice(-1);
+    const translation = `${candRow[toLanguage]}${punc}`;
+    nvdebug(`Translate relator term: ${originalTerm} => ${translation}`, debugDev);
+    return translation;
+  }
+  return originalTerm;
+}
+
+function subfieldTranslateRelatorTerm(subfield, fromLanguage, toLanguage) {
+  if (subfield.code !== 'e') {
+    return;
+  }
+  subfield.value = translateRelatorTerm(subfield.value, fromLanguage, toLanguage); // eslint-disable-line functional/immutable-data
+}
+
+export function fieldFixRelatorTerms(field, fromLanguage, toLanguage) {
+  // fromLanguage can not be relied upon.
+  if (!isRelatorField(field)/* || fromLanguage === toLanguage*/) {
+    return;
+  }
+  fieldHandleRelatorTermAbbreviations(field, fromLanguage);
+
+  field.subfields.forEach(sf => subfieldTranslateRelatorTerm(sf, fromLanguage, toLanguage));
+}
+
+
+export function recordFixRelatorTerms(record, defaultToLanguage = null, defaultFromLanguage = null) { // WAS: translateRecord()
+  const fromLanguage = defaultFromLanguage ? defaultFromLanguage : getCatalogingLanguage(record);
+  const toLanguage = defaultToLanguage ? defaultToLanguage : getCatalogingLanguage(record);
+
+  record.fields.forEach(field => translateField(field, fromLanguage, toLanguage));
+
+  function translateField(field, from, to) {
+    fieldFixRelatorTerms(field, from, to);
+  }
+}
+
+

package/src/fixRelatorTerms.spec.js

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

@@ -4,27 +4,42 @@ import DuplicatesInd1 from './duplicates-ind1';
 import EmptyFields from './empty-fields';
 import EndingPunctuation from './ending-punctuation';
 import EndingWhitespace from './ending-whitespace';
+import Field505Separators from './field-505-separators';
 import Field521Fix from './field-521-fix';
-import FieldsPresent from './fields-present';
+import FieldExclusion from './field-exclusion';
 import FieldStructure from './field-structure';
+import FieldsPresent from './fields-present';
 import FixedFields from './fixed-fields';
-import FieldExclusion from './field-exclusion';
+import FixRelatorTerms from './fixRelatorTerms';
 import IdenticalFields from './identical-fields';
+import IndicatorFixes from './indicator-fixes';
 import IsbnIssn from './isbn-issn';
 import ItemLanguage from './item-language';
+import MergeField500Lisapainokset from './mergeField500Lisapainokset';
+import MergeRelatorTermFields from './mergeRelatorTermFields';
+import MultipleSubfield0s from './multiple-subfield-0';
 import NonBreakingSpace from './non-breaking-space';
+import NormalizeIdentifiers from './normalize-identifiers';
+import NormalizeQualifyingInformation from './normalize-qualifying-information';
 import NormalizeUTF8Diacritics from './normalize-utf8-diacritics';
 import Punctuation from './punctuation/';
-import ResolveOrphanedSubfield6s from './resolveOrphanedSubfield6s'; // Do this before reindexing!
+import Punctuation2 from './punctuation2';
+import ResolveOrphanedSubfield6s from './resolveOrphanedSubfield6s'; // Do this before reindexing! (thus not in alphabetical order)
 import ReindexSubfield6OccurenceNumbers from './reindexSubfield6OccurenceNumbers';
+import RemoveDuplicateDataFields from './removeDuplicateDataFields';
+import RemoveInferiorDataFields from './removeInferiorDataFields';
 import ResolvableExtReferences from './resolvable-ext-references-melinda';
 import SanitizeVocabularySourceCodes from './sanitize-vocabulary-source-codes';
-import UpdateField540 from './update-field-540';
+import SortRelatorTerms from './sortRelatorTerms';
 import SortSubfields from './sortSubfields';
 import SortTags from './sort-tags';
+// import StripPunctuation from './stripPunctuation'; // Can we add this here? Should be used very cautiosly!
+import SubfieldValueNormalizations from './subfieldValueNormalizations';
 import SubfieldExclusion from './subfield-exclusion';
+import Sync007And300 from './sync-007-and-300';
 import TypeOfDateF008 from './typeOfDate-008';
 import UnicodeDecomposition from './unicode-decomposition';
+import UpdateField540 from './update-field-540';
 import Urn from './urn';
 
 export {
@@ -34,24 +49,38 @@ export {
   EmptyFields,
   EndingPunctuation,
   EndingWhitespace,
+  Field505Separators,
   Field521Fix,
   FieldExclusion,
   FieldsPresent,
   FieldStructure,
+  FixRelatorTerms,
   FixedFields,
   IdenticalFields,
+  IndicatorFixes,
   IsbnIssn,
   ItemLanguage,
+  MergeField500Lisapainokset,
+  MergeRelatorTermFields,
+  MultipleSubfield0s,
   NonBreakingSpace,
+  NormalizeIdentifiers,
+  NormalizeQualifyingInformation,
   NormalizeUTF8Diacritics,
   Punctuation,
+  Punctuation2,
   ResolveOrphanedSubfield6s,
   ReindexSubfield6OccurenceNumbers,
+  RemoveDuplicateDataFields,
+  RemoveInferiorDataFields,
   ResolvableExtReferences,
   SanitizeVocabularySourceCodes,
+  SortRelatorTerms,
   SortSubfields,
   SortTags,
   SubfieldExclusion,
+  SubfieldValueNormalizations,
+  Sync007And300,
   TypeOfDateF008,
   UnicodeDecomposition,
   UpdateField540,

package/src/normalize-qualifying-information.js

@@ -0,0 +1,92 @@
+//import createDebugLogger from 'debug';
+import clone from 'clone';
+import {fieldToString} from './utils';
+
+// Author(s): Nicholas Volk
+export default function () {
+
+  return {
+    // Fixes MELINDA-8740
+    description: 'Normalize qualifying information (020$q, 015$q, 024$q, 028$q)',
+    validate, fix
+  };
+
+  function fix(record) {
+    record.fields.forEach(field => {
+      normalizeQualifyingInformationField(field);
+    });
+
+    const res = {message: [], fix: [], valid: true};
+    return res;
+  }
+
+  function validate(record) {
+    const res = {message: []};
+
+    record.fields?.forEach(field => {
+      validateField(field, res);
+    });
+
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+
+  function validateField(field, res) {
+    const orig = fieldToString(field);
+
+    const normalizedField = clone(field);
+    normalizeQualifyingInformationField(normalizedField);
+    const mod = fieldToString(normalizedField);
+    if (orig !== mod) { // Fail as the input is "broken"/"crap"/sumthing
+      res.message.push(`'TODO: ${orig}' => '${mod}'`); // eslint-disable-line functional/immutable-data
+      return;
+    }
+    return;
+  }
+}
+
+
+function normalizeQualifyingInformationField(field) {
+  if (!['015', '020', '024', '028'].includes(field.tag) || !field.subfields) {
+    return;
+  }
+
+  field.subfields.forEach(sf => fixSubfield(sf));
+  return;
+
+  function fixSubfield(sf) {
+    if (sf.code !== 'q') {
+      return;
+    }
+    sf.value = normalizeValue(sf.value); // eslint-disable-line functional/immutable-data
+  }
+
+  function normalizeValue(val) {
+    // Should we do English as well: "coil bound" and "comb-bound" => "spiral-bound" (as per MTS)?
+
+    if (val.match(/^(?:hft|häftad)[.,]*$/iu)) { // MELINDA-8740
+      return 'mjuka pärmar';
+    }
+
+    if (val.match(/^inb(?:\.|unden)[.,]*$/iu)) { // MELINDA-8740
+      return 'hårda pärmar';
+    }
+
+    if (val === 'rengaskirja') { // https://www.kiwi.fi/display/melinda/Talonmies+tiedottaa+16.12.2021
+      return 'kierreselkä';
+    }
+
+    if (val === 'ringpärm') { // https://www.kiwi.fi/display/melinda/Talonmies+tiedottaa+16.12.2021
+      return 'spiralrygg';
+    }
+
+    if (val.match(/^nid(?:\.|ottu)[.,]*$/iu)) { // MELINDA-8740
+      return 'pehmeäkantinen';
+    }
+
+    if (val.match(/^sid(?:\.|ottu)[.,]*$/iu)) { // MELINDA-8740
+      return 'kovakantinen';
+    }
+    return val;
+  }
+}