@natlibfi/melinda-record-matching 5.0.4 → 5.0.5

package/package.json

@@ -13,7 +13,7 @@
 		"url": "https://github.com/NatLibFi/melinda-record-matching-js"
 	},
 	"license": "MIT",
-	"version": "5.0.4",
+	"version": "5.0.5",
 	"type": "module",
 	"main": "./dist/index.js",
 	"bin": "./dist/cli.js",
@@ -40,27 +40,23 @@
 	},
 	"dependencies": {
 		"@natlibfi/marc-record": "^10.0.1",
-		"@natlibfi/marc-record-serializers": "^11.0.1",
-		"@natlibfi/marc-record-validators-melinda": "^12.0.7",
+		"@natlibfi/marc-record-serializers": "^11.0.2",
+		"@natlibfi/marc-record-validators-melinda": "^12.0.15",
 		"@natlibfi/melinda-commons": "^14.0.2",
 		"@natlibfi/sru-client": "^7.0.1",
 		"debug": "^4.4.3",
 		"isbn3": "^2.0.6",
 		"moment": "^2.30.1",
 		"natural": "^8.1.1",
-		"uuid": "^13.0.0",
+		"uuid": "^14.0.0",
 		"yargs": "^18.0.0"
 	},
 	"devDependencies": {
 		"@natlibfi/fixugen": "^3.0.1",
-		"@natlibfi/fixugen-http-client": "^4.0.2",
+		"@natlibfi/fixugen-http-client": "^4.0.3",
 		"@natlibfi/fixura": "^4.0.1",
 		"cross-env": "^10.1.0",
-		"esbuild": "^0.27.3",
-		"eslint": "^10.0.2"
-	},
-	"overrides": {
-		"nanoid": "^3.3.8"
-	},
-	"nvolkComment": "cld3-asm 4.0.0 uses emscripten-wasm-loader ^3.0.3 which uses problematic, non-secure nanoid version 2.X.X."
+		"esbuild": "^0.28.0",
+		"eslint": "^10.2.1"
+	}
 }

package/src/candidate-search/query-list/bib.js

@@ -1,9 +1,14 @@
 import createDebugLogger from 'debug';
 import {toQueries} from '../candidate-search-utils.js';
 import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber} from '../../matching-utils.js';
+import {extractHostMelindaIdsFromField, extractPublicationYearFrom773, getHostMelindaFields} from './component.js';
+import {fieldToString} from '@natlibfi/marc-record-validators-melinda';
+import {getTitle} from '../../match-detection/features/bib/title.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query');
 
+const IS_OK_ALONE_THRESHOLD = 5;
+
 export function bibSourceIds(record) {
 
   /* Melinda's SRU-index melinda.sourceid includes source IDs from SID fields in Melinda records
@@ -126,31 +131,27 @@ export function bibHostComponents(record) {
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents');
   const debugData = debug.extend('data');
   debug(`Creating queries for hostIds`);
+  const f773s = getHostMelindaFields(record);
+  if (f773s.length !== 1) { // This needs some thinking...
+    return [];
+  }
 
-  const id = getHostId();
-  debugData(`Found id: ${JSON.stringify(id)}`);
+  const [id] = extractHostMelindaIdsFromField(f773s[0]);
+  debug(`Found id: ${JSON.stringify(id)}`);
 
-  return testStringOrNumber(id) ? [`melinda.partsofhost=${id}`] : [];
+  // NB! record.isCR() does not work if LDR/07=a, so we get year from 773$g!
+  const year = extractPublicationYearFrom773(f773s[0]);
+  debug(`${fieldToString(f773s[0])} => ${year ? year : 'N/A'}`);
+  if (year) {
+    return [`dc.date=${year} AND melinda.partsofhost=${id}`];
+  }
 
-  function getHostId() {
-    const [field] = record.get(/^773$/u);
+  return [`melinda.partsofhost=${id}`];
 
-    if (field) {
-      const {value} = field.subfields.find(({code}) => code === 'w') || {};
+}
 
-      if (testStringOrNumber(value) && (/^\(FI-MELINDA\)/u).test(String(value))) {
-        return String(value).replace(/^\(FI-MELINDA\)/u, '');
-      }
 
-      if (testStringOrNumber(value) && (/^\(FIN01\)/u).test(String(value))) {
-        return String(value).replace(/^\(FIN01\)/u, '');
-      }
 
-      return false;
-    }
-    return false;
-  }
-}
 
 // SRU search dc.title with a search phrase starting with ^ maps currently in Melinda to (probably) to *headings* index TIT
 // - Aleph cannot currently handle headings searches starting with a boolean - in these cases use word search
@@ -184,43 +185,78 @@ export function bibTitleAuthorYearAlternates(record) {
   return {queryList: Array.from(origQueryList).reverse(), queryListType: 'alternates'};
 }
 
+function getTitleForQuery(record) {
+  const title = getTitle(record, ['a']);
+  if (title) {
+    const nWords = title.split(' ');
+    // If lone $a is deemed too short, fetch $b as well:
+    // (NV: I've seen pairs with 245$a-only vs 245$a$b, so I'd like to use $a only if it is long enough)
+
+    if (nWords < 3 || title.length < 12) {
+      const [f245] = record.get('245');
+      // If punctuation is ' =' I think that f245$a is good enough despite shortness. Trying to balance between two bad situations...
+      // "Suo (= short title) siellä, vetelä (= missing $b name in another language) täällä..."
+      if (f245 && f245.subfields.find(sf => sf.code === 'a' && sf.value.match(/ =$/u)) && title.length >= IS_OK_ALONE_THRESHOLD) {
+        return title;
+      }
+      return getTitle(record, ['a', 'b']); // Try to get a longer title
+    }
+  }
+  return title;
+}
+
+function dcTitle(record, onlyTitleLength, alternates = false) {
+  const title = getTitleForQuery(record);
+  if (!testStringOrNumber(title)) {
+    return [];
+  }
+
+  const formatted = getFormattedTitle(title);
+
+  // use word search for titles starting with a boolean
+  const useWordSearch = checkUseWordSearch(formatted);
+  // Prevent too many matches / SRU crashing by having a minimum length
+  // Note that currently this fails matching if there are no matches from previous matchers
+  if (formatted.length >= onlyTitleLength && !alternates) {
+    return [`dc.title="${useWordSearch ? '' : '^'}${formatted}*"`, formatted, true];
+  }
+
+  const queryIsOkAlone = !useWordSearch && formatted.length >= IS_OK_ALONE_THRESHOLD;
+
+  // use word search without ending * also in combination searches to avoid SRU-server crashes [MRA-189]
+  return [`dc.title="${useWordSearch || !queryIsOkAlone ? '' : '^'}${formatted}${queryIsOkAlone ? '*' : ''}"`, formatted, queryIsOkAlone];
+
+  function getFormattedTitle(title) {
+    const formatted = String(title)
+      .replace(/[\-+ !"(){}\[\]<>;:.?/@*%=^_`~]/gu, ' ')
+      .replace(/[^\w\s\p{Alphabetic}]/gu, '') // Apparently matches to/works with non-aplhabetic scripts such as Chinese as well
+      .replace(/  +/gu, ' ') // Clean up concurrent spaces from eg. subfield changes
+      .trim()
+      .replace(/^(.{30}\S*) .*$/, "$1")
+      .trim();
+
+    return formatted;
+  }
+}
+
 export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = false, alternates = false, alternateQueries = []}) {
   debug(`bibTitleAuthorPublisher, onlyTitleLength: ${onlyTitleLength}, addYear: ${addYear}, alternates: ${alternates}`);
-  const title = getTitle();
-  if (testStringOrNumber(title)) {
-    const formatted = getFormatted(title);
+  const [query, formatted, queryIsOkAlone] = dcTitle(record, onlyTitleLength, alternates);
+  if (query === undefined) {
+    return [];
+  }
 
-    // use word search for titles starting with a boolean
-    const useWordSearch = checkUseWordSearch(formatted);
-    // Prevent too many matches / SRU crashing by having a minimum length
-    // Note that currently this fails matching if there are no matches from previous matchers
-    if (formatted.length >= onlyTitleLength && !alternates) {
-      return [`dc.title="${useWordSearch ? '' : '^'}${formatted}*"`];
-    }
-    const queryIsOkAlone = formatted.length >= 5;
-
-    // use word search without ending * also in combination searches to avoid SRU-server crashes [MRA-189]
-    const query = `dc.title="${useWordSearch || !queryIsOkAlone ? '' : '^'}${formatted}${queryIsOkAlone ? '*' : ''}"`;
-    debug(`query: ${query}`);
-    const newAlternateQueries = alternates ? [...alternateQueries, query] : alternateQueries;
-
-    return addAuthorsToSearch({query, queryIsOkAlone, addYear, alternates, alternateQueries: newAlternateQueries});
-
-    function getFormatted(title) {
-      const formatted = String(title)
-        .replace(/[\-+ !"(){}\[\]<>;:.?/@*%=^_`~]/gu, ' ')
-        .replace(/[^\w\s\p{Alphabetic}]/gu, '')
-        // Clean up concurrent spaces from fe. subfield changes
-        .replace(/  +/gu, ' ')
-        .trim()
-        .replace(/^(.{30}\S*) .*$/, "$1")
-        .trim();
+  debug(`query: ${query}`);
 
-      return formatted;
-    }
+  // Prevent too many matches / SRU crashing by having a minimum length
+  // Note that currently this fails matching if there are no matches from previous matchers
+  if (formatted.length >= onlyTitleLength && !alternates) {
+    return [query];
   }
 
-  return [];
+  const newAlternateQueries = alternates ? [...alternateQueries, query] : alternateQueries;
+
+  return addAuthorsToSearch({query, queryIsOkAlone, addYear, alternates, alternateQueries: newAlternateQueries});
 
   function addAuthorsToSearch({query, queryIsOkAlone = false, addYear = false, alternates = false, alternateQueries = []}) {
     debug('addAuthorsToSearch');
@@ -254,8 +290,8 @@ export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = fals
   function addYearToSearch({query, queryIsOkAlone = false, alternates = false, alternateQueries = []}) {
     const [yearQuery] = bibYear(record);
     if (yearQuery !== undefined) {
-      const newAlternateQueries = alternates ? [...alternateQueries, `${yearQuery} AND ${query}`] : alternateQueries;
-      return alternates ? newAlternateQueries : [`${yearQuery} AND ${query}`];
+      const yearAndOtherQueries = `${yearQuery} AND ${query}`;
+      return alternates ? [...alternateQueries, yearAndOtherQueries] : [yearAndOtherQueries];
     }
     if (queryIsOkAlone) {
       return alternates ? alternateQueries : [`${query}`];
@@ -263,26 +299,6 @@ export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = fals
     return [];
   }
 
-  function getTitle() {
-    const [field] = record.get(/^245$/u);
-
-    if (field) {
-      const titleString = field.subfields
-        //.filter(({code}) => ['a', 'b', 'n', 'p'].includes(code))
-        .filter(({code}) => ['a', 'b'].includes(code))
-        //.filter(({code}) => ['a'].includes(code))
-        .map(({value}) => testStringOrNumber(value) ? String(value) : '')
-        .filter(value => value)
-        // In Melinda's index subfield separators are indexed as ' '
-        .join(' ');
-
-      if (/^[1-9]$/u.test(field.ind2)) { // Skip non-filing characters
-        return titleString.slice(parseInt(field.ind2));
-      }
-      return titleString;
-    }
-    return false;
-  }
 }
 
 export function bibAuthors(record) {
@@ -349,7 +365,10 @@ export function bibPublishers(record) {
       .slice(0, 30)
       .trim();
 
-    debugData(`Publisher string: ${formatted}`);
+    debugData(`Publisher string: '${formatted}'`);
+    if (formatted.length === 0) {
+      return [];
+    }
     // use non-wildcard word search from dc.publisher
     return [`dc.publisher="${formatted}"`];
   }
@@ -358,7 +377,7 @@ export function bibPublishers(record) {
 
   function getPublisher(record) {
     //debugData(record);
-    const [field] = record.get(/^(?:260)|(?:264)$/u);
+    const [field] = record.get(/^26[04]$/u).filter(f => f.subfields.some(sf => sf.code === 'b')); // Filter removes copyright-only fields
     //debugData(field);
 
     if (field) {
@@ -367,7 +386,8 @@ export function bibPublishers(record) {
         .map(({value}) => testStringOrNumber(value) ? String(value) : '')
         .filter(value => value)
         // In Melinda's index subfield separators are indexed as ' '
-        .join(' ');
+        .join(' ')
+        .trim();
       return publisherString;
     }
     return false;
@@ -387,14 +407,17 @@ export function bibYear(record) {
 
   function getYear(record) {
     const [f008] = record.get(/^008$/u);
-    if (f008 === undefined) {
-      debug('f008 missing');
+    if (!f008 || !f008.value || f008.value.length < 11) {
+      debug('f008 missing/crappy');
       return false;
     }
 
     debugData(`f008: ${JSON.stringify(f008)}`);
     const {value} = f008;
-    return testStringOrNumber(value) ? String(value).slice(7, 11) : undefined;
+    if (value === '||||' || value === '    ') { // Meaningless values
+      return false;
+    }
+    return value.slice(7, 11);
   }
 }
 

package/src/candidate-search/query-list/component.js

@@ -1,40 +1,117 @@
 import createDebugLogger from 'debug';
 import {promisify} from 'util';
 import {toQueries} from '../candidate-search-utils.js';
-import {getSubfieldValues, testStringOrNumber, toMelindaIds} from '../../matching-utils.js';
+import {getSubfieldValues, stringAfter, stringBefore, testStringOrNumber, toMelindaIds} from '../../matching-utils.js';
+import {fieldToString, uniqArray} from '@natlibfi/marc-record-validators-melinda/dist/utils.js';
 
 const setTimeoutPromise = promisify(setTimeout); // eslint-disable-line
 
-export function hostIdMelinda(record) {
-  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:hostIdMelinda');
-  const debugData = debug.extend('data'); // eslint-disable-line
-  debug(`Creating query for the Melinda Id host`);
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:component');
+const debugData = debug.extend('data'); // eslint-disable-line
+
 
-  const ids = hostId(record);
-  if (ids.length > 0) {
-    return toQueries(ids, 'melinda.partsofhost');
+
+export function parse773g(field) {
+  const g = field?.subfields?.find(sf => sf.code === 'g'); // NB! returns the first $g
+
+  if (!g) {
+    return {};
   }
 
-  debug(`No valid Melinda Id host found`);
-  return [];
+  const value = normalizeValue(g.value);
 
-  function hostId(record) {
-    // Multi 773 handling
-    const f773s = record.get(/^773$/u)
-      .filter(f773 => f773.subfields.some(sub => sub.code === 'w' && (/\(FI-MELINDA\).*/ui).test(sub.value)));
+  return {
+    // NB! We are not currently interested in volume (vuosikerta)
+    year: gToYear(value) || null,
+    number: gToNumber(value) || null,
+    pages: gToPages(value) || null // Might also be eg. Raita 5. However, returns only the number part
+  }
 
-    if (f773s.length === 0) {
-      return false;
+  function normalizeValue(value) {
+    return value.replace(/(?:\. -|\.)$/u, '');
+  }
+
+  function gToNumber(value) {
+    // Allow up to 3-digit numbers
+    const extract1 = value.replace(/^.*: ([1-9][0-9]?[0-9]), (?:p\.|page|pp\.|s\.|Seite|sida|sidor|sivu).*$/ui, '$1');
+    if (extract1 !== value) {
+      return extract1;
     }
+    return undefined;
+  }
 
-    // Multi $w handling
-    // $w (prefix)<id> handling
-    // $w <id> & $w (prefix)<id> Match
-    const melindaIds = f773s.map(f773 => toMelindaIds(f773, ['w'])).flat()
-      .filter(value => testStringOrNumber(value)) // drop invalid values
-      .filter((value, index, array) => array.indexOf(value) === index); // unique values;
-    return melindaIds;
+  function gToPages(value) {
+    if (value.match(/^[0-9]+(?:-[0-9]+)?(?:, [0-9]+(?:-[0-9]+)?)*$/u)) {
+      return value;
+    }
+    const numberPartOnly = value.replace(/^.*(?:p\.|raidat|raita|s\.|Seite|sivut?|pages?) /ui, '');
+    if (numberPartOnly !== value) {
+      return gToPages(numberPartOnly);
+    }
+    return undefined;
+  }
+
+
+  function gToYear(value) {
+    debug(`EXTRACT YEAR FROM '${value}`);
+    // extract year from within parentheses: $g vsk (yyyy) AND $g (YYYY)
+    if (value.match(/^[1-9][0-9]?[0-9]? ?\((?:20[012][0-9]|19[0-9][0-9])\)/u) || value.match(/^\((?:20[012][0-9]|19[0-9][0-9])\)/u) ) {
+      return stringBefore(stringAfter(value, '('), ')');
+    }
+    // If volume is missing, the year often seems to come without them parentheses:
+    if (value.match(/^(?:20[012][0-9]|19[0-9][0-9]) :/u)) {
+      return stringBefore(value, ' ');
+    }
+    // Seen in SB $g (vsk)year joulukuu
+    if (value.match(/^\([1-9][0-9]?\) ?(?:20[012][0-9]|19[0-9][0-9])[^0-9]/)) {
+      return value.replace(/^\([0-9]+\) ?/u, '').replace(/[^0-9].*$/u, '');
+    }
+    // Some magazines use DD.MM.YYYY
+    if (value.match(/^[^0-9]*(?:[1-9]|[12][0-9]|30|31)\.(?:1[012]|[1-9])\. ?(?:20[012][0-9]|19[0-9][0-9])[^0-9]/u)) {
+      return value.replace(/^[^0-9]*[0-9]+\.[0-9]+\. ?/u, '').replace(/[^0-9].*$/u, '');
+    }
+
+    return undefined;
+  }
+}
+
+export function extractPublicationYearFrom773(field) {
+  const data = parse773g(field);
+  debug(`Extracted year ${data.year} from f773$g ${fieldToString(field)}`);
+  return data.year;
+}
+
+function isMelindaSubfieldW(subfield) {
+  if (subfield.code !== 'w') {
+    return false;
+  }
+  return (/^\((?:FI-MELINDA|FIN01)\)0[0-9]{8}$/ui).test(subfield.value);
+}
+
+function removeMelindaPrefixFromValue(value) {
+  return value.replace(/^(?:\(FI-MELINDA\)|\(FIN01\))/, '');
+}
+
+export function getHostMelindaFields(record) {
+  return record.get(/^773$/u).filter(f => f.subfields.some(sf => isMelindaSubfieldW(sf)));
+}
+
+export function extractHostMelindaIdsFromField(field) {
+  return field.subfields.filter(sf => isMelindaSubfieldW(sf)).map(sf => removeMelindaPrefixFromValue(sf.value));
+}
+
+export function getHostMelindaIds(record) {
+  return uniqArray(getHostMelindaFields(record).map(f => extractHostMelindaIdsFromField(f)).flat());
+}
+
+export function hostIdMelinda(record) { // old function with replaced code
+  debug(`Creating query for the Melinda Id host`);
+  const ids = getHostMelindaIds(record);
+  if (ids.length === 0) {
+    debug(`No valid Melinda Id host found`);
+    return [];
   }
+  return toQueries(getHostMelindaIds(record), 'melinda.partsofhost');
 }
 
 export async function hostIdOtherSource(record, client) {

package/src/cli.js

@@ -76,7 +76,8 @@ async function cli() {
     if (['IDS'].includes(searchType)) {
       return [
         matchDetection.features.bib.melindaId(),
-        matchDetection.features.bib.allSourceIds()
+        matchDetection.features.bib.allSourceIds(),
+        matchDetection.features.bib.f773() // Host data
       ];
     }
 
@@ -101,7 +102,8 @@ async function cli() {
         //       normal publicationTime and a reprintPublication time
         matchDetection.features.bib.publicationTimeAllowConsYearsMulti(),
         matchDetection.features.bib.language(),
-        matchDetection.features.bib.bibliographicLevel()
+        matchDetection.features.bib.bibliographicLevel(),
+        matchDetection.features.bib.f773() // Host data
       ];
     }
 
@@ -113,7 +115,8 @@ async function cli() {
         matchDetection.features.bib.title(),
         matchDetection.features.bib.language(),
         matchDetection.features.bib.authors(),
-        matchDetection.features.bib.bibliographicLevel()
+        matchDetection.features.bib.bibliographicLevel(),
+        matchDetection.features.bib.f773() // Host data
       ];
     }
 
@@ -128,7 +131,8 @@ async function cli() {
         matchDetection.features.bib.recordType(),
         matchDetection.features.bib.publicationTime(),
         matchDetection.features.bib.language(),
-        matchDetection.features.bib.bibliographicLevel()
+        matchDetection.features.bib.bibliographicLevel(),
+        matchDetection.features.bib.f773() // Host data
       ];
     }
 

package/src/match-detection/features/bib/f773.js

@@ -0,0 +1,118 @@
+// NB! This checks identifiers ($w=ID, $x=ISSN, $z=ISBN and $o=others) to check whether the host is the same.
+// BB! $g is not checked *yet*. It could very strongly indicate that the records are the same... (I doubt $q could be useful here)
+// Rationale:
+// 773$w indicates sameness. However, non-Melinda records probably refer to non-melinda hosts.
+// Thus check other identifiers subfields ($x, $z and $o as well)
+//
+
+
+import createDebugLogger from 'debug';
+
+import {isComponentRecord} from '@natlibfi/melinda-commons';
+import {uniqArray} from './issn.js';
+import {parse773g} from '../../../candidate-search/query-list/component.js';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:issn');
+const debugData = debug.extend('data');
+
+const MAX_IDENTIFIER = 0.1; // This should be pretty low: it only says something about the host
+const MAX_G = 0.5; // $g is about the comp itself, so score can be high here
+
+export default () => ({
+  name: 'f773 ',
+  extract: ({record/*, recordExternal*/}) => {
+    //const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+
+    if (!isComponentRecord(record, false, [])) {
+      return [];
+    }
+    const f773s = record.get(/^773$/u); // Identifier extract handles multiple 773...
+
+    // I think it's ok, if, say, $o and $x values match, so I'm not keeping the subfield codes
+    const values = f773s.map(f => f.subfields)
+      .flat()
+      .filter(sf => ['w', 'o', 'x', 'z'].includes(sf.code))
+      .map(sf =>  normalizeValue(sf.value));
+
+    // $g: only on $g is supported
+    const gData = parse773g(f773s[0]);
+
+    return [uniqArray(values), gData];
+
+    function normalizeValue(value) {
+      return value.replace(/(?:\. -|\.)$/u, '');
+    }
+
+
+  },
+
+  compare: (aa, bb) => {
+    const [aIdentifiers, ag] = aa;
+    const [bIdentifiers, bg] = bb;
+
+    const identifierScore = scoreIdentifiers();
+    const gScore = scoreG();
+
+    if (identifierScore === MAX_IDENTIFIER && gScore === MAX_G) { // Pretty impressive hit, even if title matches not
+      return 1.0;
+    }
+
+    return identifierScore + gScore;
+
+    function scoreG() {
+      // NB! $g contents are very noise, so wrong values may be extracted. Thus do not overpenalize.
+
+      // All exist match: things must be pretty good:
+      if (ag.number && ag.number === bg.number && ag.pages && ag.pages === bg.pages && ag.year && ag.year === bg.year) {
+        return MAX_G;
+      }
+      // Not comparing volume. It correlates with year.
+      return scoreYear() + scoreNumber() + scorePages();
+    }
+
+    function scoreNumber() {
+      if (!ag.number || !bg.number) {
+        return 0.0;
+      }
+      if (ag.number === bg.number) {
+        return 0.05;
+      }
+      return -0.02;
+    }
+
+    function scorePages() {
+      if (!ag.pages || !bg.pages) {
+        return 0.0;
+      }
+      if (ag.pages === bg.pages) { // If pages match, things must be pretty good
+        return 0.1;
+      }
+      return -0.05;
+    }
+
+    function scoreYear() { // publication-time.js also uses this, so don't score heavily here
+      if (!ag.year || !bg.year) {
+        return 0.0;
+      }
+      if (ag.year === bg.year) {
+        return 0.02;
+      }
+      return -0.02;
+    }
+
+    function scoreIdentifiers() {
+      debugData(`Comparing ISSN sets ${JSON.stringify(aIdentifiers)} and ${JSON.stringify(bIdentifiers)}`);
+      if (aIdentifiers.length === 0 || bIdentifiers.length === 0) {
+        // No data for decision
+        return 0;
+      }
+      const firstSharedIdentifier = aIdentifiers.find(val => bIdentifiers.includes(val));
+      if (firstSharedIdentifier) {
+        debug(`\t Shared identifier found: '${firstSharedIdentifier}'`);
+        return MAX_IDENTIFIER;
+      }
+      return -0.5;
+    }
+  }
+});
+

package/src/match-detection/features/bib/index.js

@@ -4,7 +4,6 @@ export {default as isbn} from './isbn.js';
 export {default as issn} from './issn.js';
 export {default as otherStandardIdentifier} from './other-standard-identifier.js';
 export {default as title} from './title.js';
-export {default as titleVersionOriginal} from './title-version-original.js';
 export {default as authors} from './authors.js';
 export {default as recordType} from './record-type.js';
 export {default as publicationTime} from './publication-time.js';
@@ -15,3 +14,4 @@ export {default as bibliographicLevel} from './bibliographic-level.js';
 export {default as melindaId} from './melinda-id.js';
 export {default as allSourceIds} from './all-source-ids.js';
 export {default as mediaType} from './media-type.js';
+export {default as f773} from './f773.js';

package/src/match-detection/features/bib/index.test.js

@@ -42,7 +42,7 @@ describe('match-detection/features/bib/', () => {
         const {featuresA, featuresB, expectedPoints} = expectations;
         const {compare} = features[feature](options);
 
-        assert.equal(compare(featuresA, featuresB), expectedPoints);
+        assert.equal(Math.round(compare(featuresA, featuresB) *100)/100, expectedPoints);
         return;
       }
 

package/src/match-detection/features/bib/isbn.js

@@ -3,8 +3,6 @@ import createDebugLogger from 'debug';
 import {parse as isbnParse} from 'isbn3';
 
 import {uniqArray} from './issn.js';
-import {isComponentRecord} from '@natlibfi/melinda-commons';
-
 
 const debug = createDebugLogger(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:ISBN`);
 const debugData = debug.extend('data');
@@ -16,12 +14,7 @@ export default () => ({
   extract: ({record/*, recordExternal*/}) => {
     //const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
 
-    const host = !isComponentRecord(record, false, []);
-
-    if (host) {
-      return record.get('020').filter(f => f.subfields?.some(sf => ['a', 'z'].includes(sf.code) && sf.value));
-    }
-    return record.get('773').filter(f => f.subfields?.some(sf => ['z'].includes(sf.code) && sf.value));
+    return record.get('020').filter(f => f.subfields?.some(sf => ['a', 'z'].includes(sf.code) && sf.value));
   },
   // eslint-disable-next-line max-statements
   compare: (aa, bb) => {
@@ -31,7 +24,8 @@ export default () => ({
       return 0;
     }
 
-    const [subfieldCodeForGoodValues, subfieldCodeForBadValues] = getSubfieldCodes(aa[0].tag);
+    const subfieldCodeForGoodValues = 'a';
+    const subfieldCodeForBadValues = 'z';
 
     const [aValidValuesA, aInvalidValuesA, zValidValuesA, zInvalidValuesA] = getValuesWrapper(aa, 'AA'); // initial 'a' and 'z' refer to 020 subfields codes
     const [aValidValuesB, aInvalidValuesB, zValidValuesB, zInvalidValuesB] = getValuesWrapper(bb, 'BB');
@@ -124,14 +118,6 @@ export default () => ({
     // We have values but they disagree:
     return -0.75; // Has good ISBNs on both records, but they did not match
 
-
-    function getSubfieldCodes(tag) {
-      if (tag === '773') {
-        return ['z', undefined];
-      }
-      return ['a', 'z'];
-    }
-
     function getValues(fields) {
       // Valid values are normalized to their isbn-13 form. Invalid values get their '-'s removed.
       const goodValues = fields.flatMap(f => f.subfields.filter(sf => sf.code === subfieldCodeForGoodValues)).map(sf => validatorAndNormalizer(sf.value));