@natlibfi/melinda-record-matching 2.0.1-alpha.1 → 2.0.7-alpha.1

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

@@ -27,8 +27,27 @@
 */
 
 import createInterface from './standard-identifier-factory';
+import {parse as isbnParse} from 'isbn3';
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:ISBN`);
+const debugData = debug.extend('data');
 
 export default () => {
-  const {extract, compare} = createInterface({pattern: /^020$/u, subfieldCodes: ['a', 'z']});
-  return {extract, compare, name: 'ISBN'};
+  const IDENTIFIER_NAME = 'ISBN';
+
+  function validatorAndNormalizer(string) {
+    const isbnParseResult = isbnParse(string);
+    debugData(`isbnParseResult: ${JSON.stringify(isbnParseResult)}`);
+    if (isbnParseResult === null) {
+      debug(`Not parseable ISBN, just removing hyphens`);
+      return {valid: false, value: string.replace(/-/ug, '')};
+    }
+    debug(`Parseable ISBN, normalizing to ISBN-13`);
+    return {valid: true, value: isbnParseResult.isbn13};
+  }
+
+  const {extract, compare} = createInterface({identifier: IDENTIFIER_NAME, pattern: /^020$/u, subfieldCodes: ['a', 'z'], validIdentifierSubfieldCodes: ['a'], invalidIdentifierSubfieldCodes: ['z'], validatorAndNormalizer});
+  return {extract, compare, name: IDENTIFIER_NAME};
 };
+

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

@@ -1,11 +1,10 @@
-/* eslint-disable max-statements */
 /**
 *
 * @licstart  The following is the entire license notice for the JavaScript code in this file.
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2023 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *
@@ -28,45 +27,43 @@
 */
 
 import createDebugLogger from 'debug';
+import {getMatchCounts} from '../../../matching-utils';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:language');
 const debugData = debug.extend('data');
 
 export default () => ({
   name: 'Language',
-  extract: record => {
+  extract: ({record, recordExternal}) => {
+    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+
     const value008 = get008Value();
     const values041 = get041Values();
-    debugData(`008: ${JSON.stringify(value008)}, 041: ${JSON.stringify(values041)}`);
-
-    if (value008 && values041.length > 0) {
-      debugData(`There's both 008 and 041, searching for value in both`);
-      const correspondingValue = values041.find(v => v === value008);
-      debugData(`Corresponding value: ${correspondingValue}`);
-      return correspondingValue ? [correspondingValue] : [];
-    }
+    debugData(`${label} 008: ${JSON.stringify(value008)}, 041: ${JSON.stringify(values041)}`);
 
     if (!value008 && values041.length < 1) {
-      debugData(`No actual values found`);
+      debugData(`{$label} No actual values found`);
       return [];
     }
 
-    return value008 ? [value008] : [values041[0]];
+    const allValues = value008 === undefined ? values041 : values041.concat(value008);
+    const uniqueSortedValues = [...new Set(allValues)].sort();
+
+    return uniqueSortedValues;
 
     function get008Value() {
       const value = record.get(/^008$/u)?.[0]?.value || undefined;
-      debugData(`008 value: ${value}`);
+      debugData(`${label} 008 value: ${value}`);
 
       if (!value) {
         return undefined;
       }
 
       const code = value.slice(35, 38);
-      debugData(`008 code: ${code}`);
-      return code === '|||' || code === '   ' || code === '^^^' ? undefined : code;
+      debugData(`${label} 008 code: ${code}`);
+      return isLangCodeForALanguage(code) ? code : undefined;
     }
 
-    // Main language for the resource: in the first f041 $a or f041 $d
     // Uses only f041s that have 2nd ind ' ', which means that the codes used are MARC 21 language codes
 
     function get041Values() {
@@ -75,23 +72,67 @@ export default () => ({
         .map(({subfields}) => subfields)
         .flat()
         .filter(({code}) => code === 'a' || code === 'd')
+        .filter(({value}) => value && isLangCodeForALanguage(value))
         .map(({value}) => value);
     }
+
+    // Check if a string is a possible, validly formed language code for a single language
+    // Currently accept also codes in capitals
+    function isLangCodeForALanguage(code) {
+      if (code.length !== 3) {
+        debugData(`Code ${code} is not correct length (3) for a language code.`);
+        return false;
+      }
+      if (code === '|||' || code === '   ' || code === '^^^' || code === 'mul' || code === 'zxx') {
+        debugData(`Code ${code} is not code for a spesific language.`);
+        return false;
+      }
+      const langCodePattern = /^[a-z][a-z][a-z]$/ui;
+      if (!langCodePattern.test(code)) {
+        debugData(`Code ${code} is not valid as a language code`);
+        return false;
+      }
+      return true;
+    }
+
   },
+  // eslint-disable-next-line max-statements
   compare: (a, b) => {
-    debugData(`Comparing ${JSON.stringify(a[0])} and ${JSON.stringify(b[0])}`);
+    debugData(`Comparing ${JSON.stringify(a)} and ${JSON.stringify(b)}`);
 
     if (a.length === 0 || b.length === 0) {
       debugData(`No language to compare`);
       return 0;
     }
 
-    debugData(`There area languages to compare`);
-
-    if (a[0] === b[0]) {
+    if (a.length === b.length && a.every((element, index) => element === b[index])) {
+      debugData(`All languages match`);
       return 0.1;
     }
 
-    return a[0] === 'und' || b[0] === 'und' ? 0.0 : -1.0;
+    const {matchingValues, possibleMatchValues, maxValues} = getMatchCounts(a, b);
+
+    if (matchingValues < 1) {
+      debug(`Both have languages, but none of these match.`);
+      return -1.0;
+    }
+    debug(`Both have languages, ${matchingValues}/${possibleMatchValues} valid languages match.`);
+    // ignore non-matches if there is mismatching amount of values
+    debug(`Possible matches: ${possibleMatchValues}/${maxValues}`);
+    //we give some kind of penalty for mismatching amount of values instead of simple divide?
+    const missingCount = maxValues - possibleMatchValues;
+    const misMatchCount = possibleMatchValues - matchingValues;
+    debug(`\t missing: ${missingCount}`);
+    debug(`\t mismatches: ${misMatchCount}`);
+
+    const penaltyForMissing = 0.02 * (maxValues - possibleMatchValues);
+    const penaltyForMisMatch = 0.05 * (possibleMatchValues - matchingValues);
+    debug(`\t points: penaltyForMissing: ${penaltyForMissing}`);
+    debug(`\t points: penaltyForMisMatch: ${penaltyForMisMatch}`);
+
+    const points = Number(Number(0.1 - penaltyForMisMatch - penaltyForMissing).toFixed(2));
+    debug(`Total points: ${points}`);
+
+    return points;
   }
 });

package/src/match-detection/features/bib/media-type.js

@@ -0,0 +1,77 @@
+/* eslint-disable max-statements */
+/**
+*
+* @licstart  The following is the entire license notice for the JavaScript code in this file.
+*
+* Melinda record matching modules for Javascript
+*
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
+*
+* This file is part of melinda-record-matching-js
+*
+* melinda-record-matching-js program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as
+* published by the Free Software Foundation, either version 3 of the
+* License, or (at your option) any later version.
+*
+* melinda-record-matching-js is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* @licend  The above is the entire license notice
+* for the JavaScript code in this file.
+*
+*/
+
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:media-type');
+const debugData = debug.extend('data');
+
+export default () => ({
+  name: 'Media type',
+  extract: ({record, recordExternal}) => {
+    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+    debugData(`Record (${label}): ${JSON.stringify(record)}`);
+    debugData(`RecordExternal: ${JSON.stringify(recordExternal)}`);
+    const values337 = get337Values();
+    debug(`${label} 337 $b values: ${JSON.stringify(values337)}`);
+
+    return values337;
+
+    function get337Values() {
+      return record.get(/^337$/u)
+        .filter(f => f.subfields.some((subfield) => subfield.code === '2' && subfield.value === 'rdamedia'))
+        .map(({subfields}) => subfields)
+        .flat()
+        .filter(({code}) => code === 'b')
+        .map(({value}) => value);
+    }
+  },
+  compare: (a, b) => {
+    debugData(`Comparing ${JSON.stringify(a)} and ${JSON.stringify(b)}`);
+
+    // Should we give extra good points if all mediaTypes match?
+    // Should we give partial points for partially matching mediaTypes?
+    // Should we check whether recordType is 'mixedMaterials'
+    // Should we okay typical cases of not totally matching mediaTypes? What would these be?
+
+    if (a.every(elem => b.includes(elem))) {
+      debug(`All mediaTypes from A are in B`);
+      return 1;
+    }
+
+    if (b.every(elem => a.includes(elem))) {
+      debug(`All mediaTypes from B are in A`);
+      return 1;
+    }
+
+    debug(`Mismatch in mediaTypes between A and B`);
+    return -1;
+
+  }
+});

package/src/match-detection/features/bib/melinda-identifier-factory.js

@@ -43,7 +43,7 @@ export default () => {
 
   return {extract, compare};
 
-  function extract(record) {
+  function extract({record, recordExternal}) {
 
     const isMelindaRecord = record.get('003').some(f003 => f003.value === 'FI-MELINDA');
     const [f001] = record.get('001').map(field => field.value);
@@ -54,7 +54,7 @@ export default () => {
       f001 === undefined &&
       f035MelindaIds.length < 1) {
 
-      debug(`No Melinda-IDs found`);
+      debug(`${recordExternal.label} No Melinda-IDs found`);
       return {};
     }
 
@@ -62,7 +62,6 @@ export default () => {
 
   }
 
-  // eslint-disable-next-line max-statements
   function compare(a, b) {
 
     if (a.isMelindaRecord && b.isMelindaRecord &&

package/src/match-detection/features/bib/other-standard-identifier.js

@@ -28,6 +28,8 @@
 
 import createInterface from './standard-identifier-factory';
 
+// DEVELOP: we should compare indicators and sf2 for f024
+
 export default () => {
   const {extract, compare} = createInterface({pattern: /^024$/u, subfieldCodes: ['a', 'z']});
   return {extract, compare, name: 'Other standard identifier'};

package/src/match-detection/features/bib/publication-time-allow-cons-years-multi.js

@@ -0,0 +1,268 @@
+/**
+*
+* @licstart  The following is the entire license notice for the JavaScript code in this file.
+*
+* Melinda record matching modules for Javascript
+*
+* Copyright (C) 2020-2023 University Of Helsinki (The National Library Of Finland)
+*
+* This file is part of melinda-record-matching-js
+*
+* melinda-record-matching-js program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as
+* published by the Free Software Foundation, either version 3 of the
+* License, or (at your option) any later version.
+*
+* melinda-record-matching-js is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* @licend  The above is the entire license notice
+* for the JavaScript code in this file.
+*
+*/
+
+import {testStringOrNumber} from '../../../matching-utils';
+import createDebugLogger from 'debug';
+
+// We should also get copyright time and copyright/publication times from 26x
+// We should also get publishing time type from f008
+// We should get reprint times from f500 $a "Lisäpainos/Lisäpainokset:"
+
+export default () => ({
+  name: 'Publication time, allow consequent years, years from multiple sources',
+  extract: ({record, recordExternal}) => {
+    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/publication-time-allow-cons-years-multi');
+    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+
+    const f008Values = extractF008Values(record);
+    debug(`${label} f008: ${JSON.stringify(f008Values)}`);
+
+    const f26xValues = extractF26xValues(record);
+    debug(`${label} f26x: ${JSON.stringify(f26xValues)}`);
+
+    const f500Values = extractF500Years(record);
+    debug(`${label} f500: ${JSON.stringify(f500Values)}`);
+
+    // We should get copyrightYear from f008Date2 to copyrightYears when f008YearType = 'r'
+    // Is the original year (f008Date2) in f008YearType === 'r' comparable to copyrightYear?
+    // We should handle unknown years (here or comparison?)
+    // We should handle year ranges for continuing resources / collections
+
+    const normalYears = [...new Set(f26xValues.normalYears.concat(f008Values.f008Date1).filter(value => value && value !== '    ' && value !== '||||'))].sort();
+    const copyrightYears = [...new Set(f26xValues.copyrightYears)].sort();
+    const reprintYears = [...new Set(f500Values)].sort();
+
+    const combined = {normalYears, copyrightYears, reprintYears};
+
+    debug(`Combined: ${JSON.stringify(combined)}`);
+
+    return combined;
+
+    function extractF008Values(record) {
+      // Record should have only one f008 - in case of several, we handle the first one
+      const value = record.get(/^008$/u)?.[0]?.value || undefined;
+      if (value && testStringOrNumber(value)) {
+        const f008Date1 = extractF008Date1(value);
+        const f008Date2 = extractF008Date2(value);
+        const f008YearType = extractF008YearType(value);
+        return {f008Date1, f008Date2, f008YearType};
+      }
+      return {f008Date1: undefined, f008Date2: undefined, f008YearType: undefined};
+
+      function extractF008Date1(value) {
+        return String(value).slice(7, 11);
+      }
+
+      function extractF008Date2(value) {
+        return String(value).slice(11, 15);
+      }
+
+      function extractF008YearType(value) {
+        return String(value).slice(6, 7);
+      }
+    }
+
+    function extractF26xValues(record) {
+      const copyrightRegex = /^(?<copyrightPrefix>cop|cop.|c|©|p|℗)/u;
+
+      const pubNormalSubFieldValues = extractPubNormalSubfieldValues(record, copyrightRegex);
+      debug(`Normal years: ${JSON.stringify(pubNormalSubFieldValues)}`);
+
+      const pubF264CopySubFieldValues = extractPubF264CopySubfieldValues(record);
+      debug(`F264 copyright years: ${JSON.stringify(pubF264CopySubFieldValues)}`);
+
+      const pubF260CopySubFieldValues = extractPubF260CopySubfieldValues(record, copyrightRegex);
+      debug(`F260 copyright years: ${JSON.stringify(pubF260CopySubFieldValues)}`);
+
+      return {normalYears: pubNormalSubFieldValues, copyrightYears: [...pubF260CopySubFieldValues, ...pubF264CopySubFieldValues]};
+
+      function extractPubNormalSubfieldValues(record, copyrightRegex) {
+        return record.get(/^26[04]$/u)
+          .filter((field) => !(field.tag === '264' && field.ind2 === '4'))
+          .map(({subfields}) => subfields)
+          .flat()
+          .filter(({code}) => code && code === 'c')
+          .filter(({value}) => value && !copyrightRegex.test(value))
+          .map(({value}) => value)
+          .map((value) => removeNonAlphaNumeric(value));
+      }
+
+      function extractPubF264CopySubfieldValues(record, copyrightRegex) {
+        return record.get(/^264$/u)
+          .filter((field) => field.ind2 === '4')
+          .map(({subfields}) => subfields)
+          .flat()
+          .filter(({code}) => code && code === 'c')
+          .filter(({value}) => value)
+          .map(({value}) => value)
+          .map((value) => value.replace(copyrightRegex, ''))
+          .map((value) => removeNonAlphaNumeric(value));
+      }
+
+      function extractPubF260CopySubfieldValues(record, copyrightRegex) {
+        return record.get(/^260$/u)
+          .map(({subfields}) => subfields)
+          .flat()
+          .filter(({code}) => code && code === 'c')
+          .filter(({value}) => value && copyrightRegex.test(value))
+          .map(({value}) => value)
+          .map((value) => value.replace(copyrightRegex, ''))
+          .map((value) => removeNonAlphaNumeric(value));
+      }
+
+      function removeNonAlphaNumeric(value) {
+        debug(`Cleaning: ${JSON.stringify(value)}`);
+        const nonAlphaNumericRegex = /[^A-Za-z0-9]/ug;
+        return value ? value.replace(nonAlphaNumericRegex, '') : value;
+      }
+    }
+
+    function extractF500Years(record) {
+
+      const reprintRegex = /(?<reprint>Lisäpainokset:|Lisäpainos:)/u;
+      const reprintFieldContents = record.get(/^500$/u)
+        .map(({subfields}) => subfields)
+        .flat()
+        .filter(({code}) => code === 'a')
+        .map(({value}) => value);
+        //.filter(value => value.test(reprintRegex));
+
+      debug(`f500 reprint field contents: ${JSON.stringify(reprintFieldContents)}`);
+
+      const filteredF500 = reprintFieldContents.filter((content) => content && content.match(reprintRegex));
+
+      debug(`f500 reprint field contents (filtered): ${JSON.stringify(filteredF500)}`);
+
+      const reprintYears = extractReprintYears(filteredF500);
+
+      return reprintYears;
+    }
+
+    function extractReprintYears(contents) {
+      const yearRegex = /[0-9][0-9][0-9][0-9]/gu;
+      const years = contents.map(content => content.match(yearRegex))
+        .flat();
+      debug(`${JSON.stringify(years)}`);
+      const uniqYears = [...new Set(years)].sort();
+      debug(`${JSON.stringify(uniqYears)}`);
+      return uniqYears;
+    }
+
+  },
+  // eslint-disable-next-line max-statements
+  compare: (a, b) => {
+    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/publication-time-allow-cons-years-multi');
+    debug(`Comparing ${JSON.stringify(a)} to ${JSON.stringify(b)}`);
+
+    const [firstA] = a.normalYears ? a.normalYears : a;
+    const [firstB] = b.normalYears ? b.normalYears : b;
+
+    debug(`Comparing ${JSON.stringify(firstA)} to ${JSON.stringify(firstB)}`);
+
+    if (firstA === firstB) {
+      return 0.1;
+    }
+
+    // If either of years is a non string/number, values are not comparable
+    if (!testStringOrNumber(firstA) || !testStringOrNumber(firstB)) {
+      return 0;
+    }
+
+    const firstANumber = parseInt(firstA, 10);
+    const firstBNumber = parseInt(firstB, 10);
+
+    // Handle consequent years as a match
+    // see publication-time for a version that does not handle consequent years as a match
+    if (!(isNaN(firstANumber) || isNaN(firstBNumber)) &&
+       (firstANumber + 1 === firstBNumber || firstANumber - 1 === firstBNumber)) {
+      return 0.1;
+    }
+
+    // We should do something with copyrightYears, too
+
+    // Do not give minus points if a normal publishing year is found in normal years
+    const bNormalInANormal = a.normalYears.filter(aValue => b.normalYears.some(bValue => aValue === bValue));
+    const aNormalInBNormal = b.normalYears.filter(bValue => a.normalYears.some(aValue => bValue === aValue));
+    debug(`BNorm in ANorm: ${JSON.stringify(bNormalInANormal)}`);
+    debug(`ANorm in BNorm: ${JSON.stringify(aNormalInBNormal)}`);
+
+    if (bNormalInANormal > 0 || aNormalInBNormal > 0) {
+      return 0;
+    }
+
+    // Do not give minus points if a normal publishing year is found in reprint years
+    const bNormalInAReprint = a.reprintYears.filter(aValue => b.normalYears.some(bValue => aValue === bValue));
+    const aNormalInBReprint = b.reprintYears.filter(bValue => a.normalYears.some(aValue => bValue === aValue));
+    debug(`BNorm in AReprint: ${JSON.stringify(bNormalInAReprint)}`);
+    debug(`ANorm in BReprint: ${JSON.stringify(aNormalInBReprint)}`);
+
+    if (bNormalInAReprint > 0 || aNormalInBReprint > 0) {
+      return 0;
+    }
+
+    return -1;
+
+  }
+});
+
+// https://www.loc.gov/marc/bibliographic/bd008.html
+// field 008
+// 06 - Type of date/Publication status
+// 07-10 - Date 1
+// 11-14 - Date 2
+//
+// 06 - Type of date/Publication status
+// b - No dates given; B.C. date involved
+// c - Continuing resource currently published
+// d - Continuing resource ceased publication
+// e - Detailed date
+// i - Inclusive dates of collection
+// k - Range of years of bulk of collection
+// m - Multiple dates
+// n - Dates unknown
+// p - Date of distribution/release/issue and production/recording session when different
+// q - Questionable date
+// r - Reprint/reissue date and original date
+// s - Single known date/probable date
+// t - Publication date and copyright date
+// u - Continuing resource status unknown
+// | - No attempt to code
+//
+// 07-10 - Date 1
+// 1-9 - Date digit
+// # - Date element is not applicable
+// u - Date element is totally or partially unknown
+// |||| - No attempt to code
+//
+// 11-14 - Date 2
+// 1-9 - Date digit
+// # - Date element is not applicable
+// u - Date element is totally or partially unknown
+// |||| - No attempt to code
+//
+

package/src/match-detection/features/bib/publication-time-allow-cons-years.js

@@ -0,0 +1,67 @@
+/**
+*
+* @licstart  The following is the entire license notice for the JavaScript code in this file.
+*
+* Melinda record matching modules for Javascript
+*
+* Copyright (C) 2020-2023 University Of Helsinki (The National Library Of Finland)
+*
+* This file is part of melinda-record-matching-js
+*
+* melinda-record-matching-js program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as
+* published by the Free Software Foundation, either version 3 of the
+* License, or (at your option) any later version.
+*
+* melinda-record-matching-js is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* @licend  The above is the entire license notice
+* for the JavaScript code in this file.
+*
+*/
+
+import {testStringOrNumber} from '../../../matching-utils';
+import createDebugLogger from 'debug';
+
+// We should also get copyright time and copyright/publication times from 26x
+
+export default () => ({
+  name: 'Publication time, allow consequent years',
+  extract: ({record}) => {
+    const value = record.get(/^008$/u)?.[0]?.value || undefined;
+    return testStringOrNumber(value) ? [String(value).slice(7, 11)] : [];
+  },
+  compare: (a, b) => {
+    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/publication-time-allow-cons-years');
+    debug(`Comparing ${a[0]} to ${b[0]}`);
+
+    const [firstA] = a;
+    const [firstB] = b;
+
+    if (firstA === firstB) {
+      return 0.1;
+    }
+
+    // If either of years is a non string/number, values are not comparable
+    if (!testStringOrNumber(firstA) || !testStringOrNumber(firstB)) {
+      return 0;
+    }
+
+    const firstANumber = parseInt(firstA, 10);
+    const firstBNumber = parseInt(firstB, 10);
+
+    if (isNaN(firstANumber) || isNaN(firstBNumber)) {
+      return -1;
+    }
+
+    // Handle consequent years as a match
+    // see publication-time for a version that does not handle consequent years as a match
+    return firstANumber + 1 === firstBNumber || firstANumber - 1 === firstBNumber ? 0.1 : -1;
+  }
+});

package/src/match-detection/features/bib/publication-time.js

@@ -4,7 +4,7 @@
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *
@@ -26,11 +26,16 @@
 *
 */
 
+import {testStringOrNumber} from '../../../matching-utils';
+
+// We should also get copyright time and copyright/publication times from 26x
+// see publication-time-allow-cons-years for a version allowing consequent years to match
+
 export default () => ({
   name: 'Publication time',
-  extract: record => {
-    const value = record.get(/^008$/u)?.[0]?.value || '';
-    return value ? [value.slice(7, 11)] : [];
+  extract: ({record}) => {
+    const value = record.get(/^008$/u)?.[0]?.value || undefined;
+    return testStringOrNumber(value) ? [String(value).slice(7, 11)] : [];
   },
   compare: (a, b) => a[0] === b[0] ? 0.1 : -1.0
 });

package/src/match-detection/features/bib/record-type.js

@@ -26,8 +26,12 @@
 *
 */
 
+// we could handle the case of books/notes
+// Recordtype: LDR/06 - Type of Record
+// Note: currently matchValidator fails all mismatching recordTypes, so this won't actually do much
+
 export default () => ({
   name: 'Record type',
-  extract: r => r.leader[6] ? [r.leader[6]] : [],
+  extract: ({record}) => record.leader[6] ? [record.leader[6]] : [],
   compare: (a, b) => a[0] === b[0] ? 0.1 : -0.5
 });