@natlibfi/melinda-record-matching 4.4.0-alpha.1 → 5.0.0-alpha.2

package/dist/match-detection/features/bib/record-type.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"record-type.js","names":["_default","name","extract","record","leader","compare","a","b","exports","default"],"sources":["../../../../src/match-detection/features/bib/record-type.js"],"sourcesContent":["/**\n*\n* @licstart  The following is the entire license notice for the JavaScript code in this file.\n*\n* Melinda record matching modules for Javascript\n*\n* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)\n*\n* This file is part of melinda-record-matching-js\n*\n* melinda-record-matching-js program is free software: you can redistribute it and/or modify\n* it under the terms of the GNU Lesser General Public License as\n* published by the Free Software Foundation, either version 3 of the\n* License, or (at your option) any later version.\n*\n* melinda-record-matching-js is distributed in the hope that it will be useful,\n* but WITHOUT ANY WARRANTY; without even the implied warranty of\n* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n* GNU Lesser General Public License for more details.\n*\n* You should have received a copy of the GNU Affero General Public License\n* along with this program.  If not, see <http://www.gnu.org/licenses/>.\n*\n* @licend  The above is the entire license notice\n* for the JavaScript code in this file.\n*\n*/\n\n// we could handle the case of books/notes\n// Recordtype: LDR/06 - Type of Record\n// Note: currently matchValidator fails all mismatching recordTypes, so this won't actually do much\n\nexport default () => ({\n  name: 'Record type',\n  extract: ({record}) => record.leader[6] ? [record.leader[6]] : [],\n  compare: (a, b) => a[0] === b[0] ? 0.1 : -0.5\n});\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAAA,IAAAA,QAAA,GAEeA,CAAA,MAAO;EACpBC,IAAI,EAAE,aAAa;EACnBC,OAAO,EAAEA,CAAC;IAACC;EAAM,CAAC,KAAKA,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,GAAG,CAACD,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE;EACjEC,OAAO,EAAEA,CAACC,CAAC,EAAEC,CAAC,KAAKD,CAAC,CAAC,CAAC,CAAC,KAAKC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;AAC5C,CAAC,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAT,QAAA"}
+{
+  "version": 3,
+  "sources": ["../../../../src/match-detection/features/bib/record-type.js"],
+  "sourcesContent": ["\n// we could handle the case of books/notes\n// Recordtype: LDR/06 - Type of Record\n// Note: currently matchValidator fails all mismatching recordTypes, so this won't actually do much\n\nexport default () => ({\n  name: 'Record type',\n  extract: ({record}) => record.leader[6] ? [record.leader[6]] : [],\n  compare: (a, b) => a[0] === b[0] ? 0.1 : -0.5\n});\n"],
+  "mappings": "AAKA,eAAe,OAAO;AAAA,EACpB,MAAM;AAAA,EACN,SAAS,CAAC,EAAC,OAAM,MAAM,OAAO,OAAO,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAC,IAAI,CAAC;AAAA,EAChE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,MAAM;AAC3C;",
+  "names": []
+}

package/dist/match-detection/features/bib/standard-identifier-factory.js

@@ -1,127 +1,37 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _debug = _interopRequireDefault(require("debug"));
-var _matchingUtils = require("../../../matching-utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/* 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.
-*
-*/
-// Note about validity of standardIdentifiers:
-// We have three types of invalid standardIdentifiers:
-// 1. Formally invalid standardIdentifiers (ie. typos either in the resource or the record)
-// 2. Formally valid standardIdentifiers that are used in a wrong resource
-// 3. Canceled standardIdentifiers
-// Matcher could and should check that a standardIdentifier found in a subfield for a valid identifier is formally valid, and if it's not formally valid, handle it as an invalid standardIdentifier
-// Formally valid standardIdentifiers found in subfield for invalid identifier cannot be handled as valid standardIdentifiers, because they can be a case of type 2) or 3) invalid standardIdentifiers
-// We could also do a separate handling for formally valid an formally invalid standardIdentifiers
-var _default = ({
-  pattern,
-  subfieldCodes,
-  identifier,
-  validIdentifierSubfieldCodes = ['a'],
-  invalidIdentifierSubfieldCodes = ['z'],
-  validatorAndNormalizer = undefined
-}) => {
-  const debug = (0, _debug.default)(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:${identifier}`);
-  const debugData = debug.extend('data');
-  return {
-    extract,
-    compare
-  };
-  function extract({
-    record,
-    recordExternal
-  }) {
-    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+import createDebugLogger from "debug";
+import { extractSubfieldsFromField, uniqueSubfields } from "../../../matching-utils.js";
+export default ({ pattern, subfieldCodes, identifier, validIdentifierSubfieldCodes = ["a"], invalidIdentifierSubfieldCodes = ["z"], validatorAndNormalizer = void 0 }) => {
+  const debug = createDebugLogger(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:${identifier}`);
+  const debugData = debug.extend("data");
+  return { extract, compare };
+  function extract({ record, recordExternal }) {
+    const label = recordExternal && recordExternal.label ? recordExternal.label : "record";
     const fields = record.get(pattern);
     debugData(`${label}: ${fields.length} ${identifier}-fields `);
-
-    // extractIdentifierSubfield normalizes hyphens away from the subfield values
-    const identifiersFromFields = fields.map(field => (0, _matchingUtils.extractSubfieldsFromField)(field, subfieldCodes));
+    const identifiersFromFields = fields.map((field) => extractSubfieldsFromField(field, subfieldCodes));
     debugData(`${label}: IDs from fields (${identifiersFromFields.length}): ${JSON.stringify(identifiersFromFields)}`);
     const allIdentifiers = identifiersFromFields.flat();
     debugData(`${label}: Flat IDs from fields (${allIdentifiers.length}): ${JSON.stringify(allIdentifiers)}`);
-    const validatedAndNormalizedIdentifiers = validateAndNormalizeIdentifiers({
-      identifierSubs: allIdentifiers,
-      validatorAndNormalizer,
-      validIdentifierSubfieldCodes,
-      invalidIdentifierSubfieldCodes
-    });
-    const identifiers = (0, _matchingUtils.uniqueSubfields)(validatedAndNormalizedIdentifiers);
+    const validatedAndNormalizedIdentifiers = validateAndNormalizeIdentifiers({ identifierSubs: allIdentifiers, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes });
+    const identifiers = uniqueSubfields(validatedAndNormalizedIdentifiers);
     debugData(`${label}: Unique IDs from fields (${identifiers.length}): ${JSON.stringify(identifiers)}`);
     return identifiers;
-    function validateAndNormalizeIdentifiers({
-      identifierSubs,
-      validatorAndNormalizer,
-      validIdentifierSubfieldCodes,
-      invalidIdentifierSubfieldCodes
-    }) {
-      if (validatorAndNormalizer) {
-        return identifierSubs.map(idSub => validateAndNormalizeIdentifier({
-          idSub,
-          validatorAndNormalizer,
-          validIdentifierSubfieldCodes,
-          invalidIdentifierSubfieldCodes
-        }));
+    function validateAndNormalizeIdentifiers({ identifierSubs, validatorAndNormalizer: validatorAndNormalizer2, validIdentifierSubfieldCodes: validIdentifierSubfieldCodes2, invalidIdentifierSubfieldCodes: invalidIdentifierSubfieldCodes2 }) {
+      if (validatorAndNormalizer2) {
+        return identifierSubs.map((idSub) => validateAndNormalizeIdentifier({ idSub, validatorAndNormalizer: validatorAndNormalizer2, validIdentifierSubfieldCodes: validIdentifierSubfieldCodes2, invalidIdentifierSubfieldCodes: invalidIdentifierSubfieldCodes2 }));
       }
-      return identifierSubs.map(idSub => normalizeHyphens(idSub));
+      return identifierSubs.map((idSub) => normalizeHyphens(idSub));
     }
-    function validateAndNormalizeIdentifier({
-      idSub,
-      validatorAndNormalizer,
-      validIdentifierSubfieldCodes,
-      invalidIdentifierSubfieldCodes
-    }) {
-      const {
-        valid,
-        value
-      } = validatorAndNormalizer(idSub.value);
-      if (validIdentifierSubfieldCodes.includes(idSub.code) && valid === false) {
-        const [code] = invalidIdentifierSubfieldCodes;
-        return {
-          code,
-          value
-        };
+    function validateAndNormalizeIdentifier({ idSub, validatorAndNormalizer: validatorAndNormalizer2, validIdentifierSubfieldCodes: validIdentifierSubfieldCodes2, invalidIdentifierSubfieldCodes: invalidIdentifierSubfieldCodes2 }) {
+      const { valid, value } = validatorAndNormalizer2(idSub.value);
+      if (validIdentifierSubfieldCodes2.includes(idSub.code) && valid === false) {
+        const [code] = invalidIdentifierSubfieldCodes2;
+        return { code, value };
       }
-      return {
-        code: idSub.code,
-        value
-      };
+      return { code: idSub.code, value };
     }
     function normalizeHyphens(idSub) {
-      return {
-        code: idSub.code,
-        value: idSub.value.replace(/-/ug, '')
-      };
+      return { code: idSub.code, value: idSub.value.replace(/-/ug, "") };
     }
   }
   function compare(a, b) {
@@ -133,41 +43,25 @@ var _default = ({
     debugData(`A: ${JSON.stringify(a)}`);
     debugData(`B: ${JSON.stringify(b)}`);
     if (bothHaveValidIdentifiers()) {
-      // Compare only valid identifiers, if both have valid idenfiers
-      const {
-        maxValues,
-        possibleMatchValues,
-        matchingValues
-      } = getValueCount(true);
-      if (matchingValues < 1) {
+      const { maxValues: maxValues2, possibleMatchValues, matchingValues: matchingValues2 } = getValueCount(true);
+      if (matchingValues2 < 1) {
         debug(`Both have valid standardidentifiers (${identifier}), but none of these match.`);
         return -0.75;
       }
-      debug(`Both have valid standardidentifiers (${identifier}), ${matchingValues}/${possibleMatchValues} valid identifiers 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 penaltyForMissing = 0.1 * (maxValues - possibleMatchValues);
-      const penaltyForMisMatch = 0.2 * (possibleMatchValues - matchingValues);
-      debug(`\t points: penaltyForMissing: ${penaltyForMissing}`);
-      debug(`\t points: penaltyForMisMatch: ${penaltyForMisMatch}`);
+      debug(`Both have valid standardidentifiers (${identifier}), ${matchingValues2}/${possibleMatchValues} valid identifiers match.`);
+      debug(`Possible matches: ${possibleMatchValues}/${maxValues2}`);
+      const penaltyForMissing = 0.1 * (maxValues2 - possibleMatchValues);
+      const penaltyForMisMatch = 0.2 * (possibleMatchValues - matchingValues2);
+      debug(`	 points: penaltyForMissing: ${penaltyForMissing}`);
+      debug(`	 points: penaltyForMisMatch: ${penaltyForMisMatch}`);
       return 0.75 - penaltyForMisMatch - penaltyForMissing;
-      //return matchingValues / possibleMatchValues * 0.75;
     }
-    // If both do not have valid identifiers, compare all identifiers
-    const {
-      maxValues,
-      matchingValues
-    } = getValueCount();
+    const { maxValues, matchingValues } = getValueCount();
     debug(`Both do NOT have valid standardidentifiers (${identifier}), ${matchingValues}/${maxValues} valid/invalid identifiers match.`);
     return matchingValues / maxValues * 0.2;
     function bothHaveValidIdentifiers() {
-      const aValues = a.filter(({
-        code
-      }) => validIdentifierSubfieldCodes.includes(code));
-      const bValues = a.filter(({
-        code
-      }) => validIdentifierSubfieldCodes.includes(code));
+      const aValues = a.filter(({ code }) => validIdentifierSubfieldCodes.includes(code));
+      const bValues = a.filter(({ code }) => validIdentifierSubfieldCodes.includes(code));
       debug(`A: ${aValues.length} valid ${identifier} identifiers`);
       debug(`B: ${bValues.length} valid ${identifier} identifiers`);
       return aValues.length > 0 && bValues.length > 0;
@@ -175,41 +69,31 @@ var _default = ({
     function getValueCount(validOnly = false) {
       const aValues = getIdentifiers(a, validOnly);
       const bValues = getIdentifiers(b, validOnly);
-      const matchingValues = getMatchingValuesAmount(aValues, bValues);
+      const matchingValues2 = getMatchingValuesAmount(aValues, bValues);
       return {
         maxValues: aValues.length > bValues.length ? aValues.length : bValues.length,
         // possibleMatchingValues: amount of identifiers in set of less identifiers (we cannot more values than these)
         possibleMatchValues: aValues.length > bValues.length ? bValues.length : aValues.length,
-        matchingValues
+        matchingValues: matchingValues2
       };
-      function getMatchingValuesAmount(aValues, bValues) {
-        if (bValues.length > aValues.length) {
-          return aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;
+      function getMatchingValuesAmount(aValues2, bValues2) {
+        if (bValues2.length > aValues2.length) {
+          return aValues2.filter((aValue) => bValues2.some((bValue) => aValue === bValue)).length;
         }
-        if (aValues.length > bValues.length) {
-          return bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;
+        if (aValues2.length > bValues2.length) {
+          return bValues2.filter((bValue) => aValues2.some((aValue) => bValue === aValue)).length;
         }
-
-        // If we have same amount of values, we'll check matches both ways, to avoid mixups in cases
-        // there would be duplicate values
-        const aToB = aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;
-        const bToA = bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;
+        const aToB = aValues2.filter((aValue) => bValues2.some((bValue) => aValue === bValue)).length;
+        const bToA = bValues2.filter((bValue) => aValues2.some((aValue) => bValue === aValue)).length;
         return aToB < bToA ? aToB : bToA;
       }
-      function getIdentifiers(values, validOnly) {
-        if (validOnly) {
-          return values.filter(({
-            code
-          }) => validIdentifierSubfieldCodes.includes(code)).map(({
-            value
-          }) => value);
+      function getIdentifiers(values, validOnly2) {
+        if (validOnly2) {
+          return values.filter(({ code }) => validIdentifierSubfieldCodes.includes(code)).map(({ value }) => value);
         }
-        return values.map(({
-          value
-        }) => value);
+        return values.map(({ value }) => value);
       }
     }
   }
 };
-exports.default = _default;
-//# sourceMappingURL=standard-identifier-factory.js.map
+//# sourceMappingURL=standard-identifier-factory.js.map

package/dist/match-detection/features/bib/standard-identifier-factory.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"standard-identifier-factory.js","names":["_debug","_interopRequireDefault","require","_matchingUtils","obj","__esModule","default","_default","pattern","subfieldCodes","identifier","validIdentifierSubfieldCodes","invalidIdentifierSubfieldCodes","validatorAndNormalizer","undefined","debug","createDebugLogger","debugData","extend","extract","compare","record","recordExternal","label","fields","get","length","identifiersFromFields","map","field","extractSubfieldsFromField","JSON","stringify","allIdentifiers","flat","validatedAndNormalizedIdentifiers","validateAndNormalizeIdentifiers","identifierSubs","identifiers","uniqueSubfields","idSub","validateAndNormalizeIdentifier","normalizeHyphens","valid","value","includes","code","replace","a","b","bothHaveValidIdentifiers","maxValues","possibleMatchValues","matchingValues","getValueCount","penaltyForMissing","penaltyForMisMatch","aValues","filter","bValues","validOnly","getIdentifiers","getMatchingValuesAmount","aValue","some","bValue","aToB","bToA","values","exports"],"sources":["../../../../src/match-detection/features/bib/standard-identifier-factory.js"],"sourcesContent":["/* eslint-disable max-statements */\n/**\n*\n* @licstart  The following is the entire license notice for the JavaScript code in this file.\n*\n* Melinda record matching modules for Javascript\n*\n* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)\n*\n* This file is part of melinda-record-matching-js\n*\n* melinda-record-matching-js program is free software: you can redistribute it and/or modify\n* it under the terms of the GNU Lesser General Public License as\n* published by the Free Software Foundation, either version 3 of the\n* License, or (at your option) any later version.\n*\n* melinda-record-matching-js is distributed in the hope that it will be useful,\n* but WITHOUT ANY WARRANTY; without even the implied warranty of\n* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n* GNU Lesser General Public License for more details.\n*\n* You should have received a copy of the GNU Affero General Public License\n* along with this program.  If not, see <http://www.gnu.org/licenses/>.\n*\n* @licend  The above is the entire license notice\n* for the JavaScript code in this file.\n*\n*/\n\nimport createDebugLogger from 'debug';\nimport {extractSubfieldsFromField, uniqueSubfields} from '../../../matching-utils';\n\n// Note about validity of standardIdentifiers:\n// We have three types of invalid standardIdentifiers:\n// 1. Formally invalid standardIdentifiers (ie. typos either in the resource or the record)\n// 2. Formally valid standardIdentifiers that are used in a wrong resource\n// 3. Canceled standardIdentifiers\n\n// Matcher could and should check that a standardIdentifier found in a subfield for a valid identifier is formally valid, and if it's not formally valid, handle it as an invalid standardIdentifier\n// Formally valid standardIdentifiers found in subfield for invalid identifier cannot be handled as valid standardIdentifiers, because they can be a case of type 2) or 3) invalid standardIdentifiers\n// We could also do a separate handling for formally valid an formally invalid standardIdentifiers\n\nexport default ({pattern, subfieldCodes, identifier, validIdentifierSubfieldCodes = ['a'], invalidIdentifierSubfieldCodes = ['z'], validatorAndNormalizer = undefined}) => {\n  const debug = createDebugLogger(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:${identifier}`);\n  const debugData = debug.extend('data');\n\n  return {extract, compare};\n\n  function extract({record, recordExternal}) {\n    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';\n    const fields = record.get(pattern);\n    debugData(`${label}: ${fields.length} ${identifier}-fields `);\n\n    // extractIdentifierSubfield normalizes hyphens away from the subfield values\n    const identifiersFromFields = fields.map(field => extractSubfieldsFromField(field, subfieldCodes));\n    debugData(`${label}: IDs from fields (${identifiersFromFields.length}): ${JSON.stringify(identifiersFromFields)}`);\n    const allIdentifiers = identifiersFromFields.flat();\n    debugData(`${label}: Flat IDs from fields (${allIdentifiers.length}): ${JSON.stringify(allIdentifiers)}`);\n\n    const validatedAndNormalizedIdentifiers = validateAndNormalizeIdentifiers({identifierSubs: allIdentifiers, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes});\n\n    const identifiers = uniqueSubfields(validatedAndNormalizedIdentifiers);\n\n    debugData(`${label}: Unique IDs from fields (${identifiers.length}): ${JSON.stringify(identifiers)}`);\n    return identifiers;\n\n    function validateAndNormalizeIdentifiers({identifierSubs, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}) {\n      if (validatorAndNormalizer) {\n        return identifierSubs.map((idSub) => validateAndNormalizeIdentifier({idSub, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}));\n      }\n      return identifierSubs.map((idSub) => normalizeHyphens(idSub));\n    }\n\n    function validateAndNormalizeIdentifier({idSub, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}) {\n      const {valid, value} = validatorAndNormalizer(idSub.value);\n      if (validIdentifierSubfieldCodes.includes(idSub.code) && valid === false) {\n        const [code] = invalidIdentifierSubfieldCodes;\n        return {code, value};\n      }\n      return {code: idSub.code, value};\n    }\n\n    function normalizeHyphens(idSub) {\n      return {code: idSub.code, value: idSub.value.replace(/-/ug, '')};\n    }\n\n\n  }\n\n  function compare(a, b) {\n    debug(`Comparing A and B`);\n    if (a.length === 0 || b.length === 0) {\n      debugData(`No standardidentifiers (${identifier}) to compare`);\n      return 0;\n    }\n\n    debugData(`A: ${JSON.stringify(a)}`);\n    debugData(`B: ${JSON.stringify(b)}`);\n\n\n    if (bothHaveValidIdentifiers()) {\n      // Compare only valid identifiers, if both have valid idenfiers\n      const {maxValues, possibleMatchValues, matchingValues} = getValueCount(true);\n      if (matchingValues < 1) {\n        debug(`Both have valid standardidentifiers (${identifier}), but none of these match.`);\n        return -0.75;\n      }\n      debug(`Both have valid standardidentifiers (${identifier}), ${matchingValues}/${possibleMatchValues} valid identifiers match.`);\n      // ignore non-matches if there is mismatching amount of values\n      debug(`Possible matches: ${possibleMatchValues}/${maxValues}`);\n      //we give some kind of penalty for mismatching amount of values instead of simple divide?\n      const penaltyForMissing = 0.1 * (maxValues - possibleMatchValues);\n      const penaltyForMisMatch = 0.2 * (possibleMatchValues - matchingValues);\n      debug(`\\t points: penaltyForMissing: ${penaltyForMissing}`);\n      debug(`\\t points: penaltyForMisMatch: ${penaltyForMisMatch}`);\n\n      return 0.75 - penaltyForMisMatch - penaltyForMissing;\n      //return matchingValues / possibleMatchValues * 0.75;\n    }\n    // If both do not have valid identifiers, compare all identifiers\n    const {maxValues, matchingValues} = getValueCount();\n    debug(`Both do NOT have valid standardidentifiers (${identifier}), ${matchingValues}/${maxValues} valid/invalid identifiers match.`);\n\n    return matchingValues / maxValues * 0.2;\n\n    function bothHaveValidIdentifiers() {\n      const aValues = a.filter(({code}) => validIdentifierSubfieldCodes.includes(code));\n      const bValues = a.filter(({code}) => validIdentifierSubfieldCodes.includes(code));\n      debug(`A: ${aValues.length} valid ${identifier} identifiers`);\n      debug(`B: ${bValues.length} valid ${identifier} identifiers`);\n      return aValues.length > 0 && bValues.length > 0;\n    }\n\n    function getValueCount(validOnly = false) {\n      const aValues = getIdentifiers(a, validOnly);\n      const bValues = getIdentifiers(b, validOnly);\n\n      const matchingValues = getMatchingValuesAmount(aValues, bValues);\n\n      return {\n        maxValues: aValues.length > bValues.length ? aValues.length : bValues.length,\n        // possibleMatchingValues: amount of identifiers in set of less identifiers (we cannot more values than these)\n        possibleMatchValues: aValues.length > bValues.length ? bValues.length : aValues.length,\n        matchingValues\n      };\n\n      function getMatchingValuesAmount(aValues, bValues) {\n        if (bValues.length > aValues.length) {\n          return aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;\n        }\n        if (aValues.length > bValues.length) {\n          return bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;\n        }\n\n        // If we have same amount of values, we'll check matches both ways, to avoid mixups in cases\n        // there would be duplicate values\n        const aToB = aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;\n        const bToA = bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;\n\n        return aToB < bToA ? aToB : bToA;\n      }\n\n      function getIdentifiers(values, validOnly) {\n        if (validOnly) {\n          return values\n            .filter(({code}) => validIdentifierSubfieldCodes.includes(code))\n            .map(({value}) => value);\n        }\n\n        return values.map(({value}) => value);\n      }\n    }\n  }\n};\n"],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../../../../src/match-detection/features/bib/standard-identifier-factory.js"],
+  "sourcesContent": ["/* eslint-disable max-statements */\n\nimport createDebugLogger from 'debug';\nimport {extractSubfieldsFromField, uniqueSubfields} from '../../../matching-utils.js';\n\n// Note about validity of standardIdentifiers:\n// We have three types of invalid standardIdentifiers:\n// 1. Formally invalid standardIdentifiers (ie. typos either in the resource or the record)\n// 2. Formally valid standardIdentifiers that are used in a wrong resource\n// 3. Canceled standardIdentifiers\n\n// Matcher could and should check that a standardIdentifier found in a subfield for a valid identifier is formally valid, and if it's not formally valid, handle it as an invalid standardIdentifier\n// Formally valid standardIdentifiers found in subfield for invalid identifier cannot be handled as valid standardIdentifiers, because they can be a case of type 2) or 3) invalid standardIdentifiers\n// We could also do a separate handling for formally valid an formally invalid standardIdentifiers\n\nexport default ({pattern, subfieldCodes, identifier, validIdentifierSubfieldCodes = ['a'], invalidIdentifierSubfieldCodes = ['z'], validatorAndNormalizer = undefined}) => {\n  const debug = createDebugLogger(`@natlibfi/melinda-record-matching:match-detection:features:standard-identifiers:${identifier}`);\n  const debugData = debug.extend('data');\n\n  return {extract, compare};\n\n  function extract({record, recordExternal}) {\n    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';\n    const fields = record.get(pattern);\n    debugData(`${label}: ${fields.length} ${identifier}-fields `);\n\n    // extractIdentifierSubfield normalizes hyphens away from the subfield values\n    const identifiersFromFields = fields.map(field => extractSubfieldsFromField(field, subfieldCodes));\n    debugData(`${label}: IDs from fields (${identifiersFromFields.length}): ${JSON.stringify(identifiersFromFields)}`);\n    const allIdentifiers = identifiersFromFields.flat();\n    debugData(`${label}: Flat IDs from fields (${allIdentifiers.length}): ${JSON.stringify(allIdentifiers)}`);\n\n    const validatedAndNormalizedIdentifiers = validateAndNormalizeIdentifiers({identifierSubs: allIdentifiers, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes});\n\n    const identifiers = uniqueSubfields(validatedAndNormalizedIdentifiers);\n\n    debugData(`${label}: Unique IDs from fields (${identifiers.length}): ${JSON.stringify(identifiers)}`);\n    return identifiers;\n\n    function validateAndNormalizeIdentifiers({identifierSubs, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}) {\n      if (validatorAndNormalizer) {\n        return identifierSubs.map((idSub) => validateAndNormalizeIdentifier({idSub, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}));\n      }\n      return identifierSubs.map((idSub) => normalizeHyphens(idSub));\n    }\n\n    function validateAndNormalizeIdentifier({idSub, validatorAndNormalizer, validIdentifierSubfieldCodes, invalidIdentifierSubfieldCodes}) {\n      const {valid, value} = validatorAndNormalizer(idSub.value);\n      if (validIdentifierSubfieldCodes.includes(idSub.code) && valid === false) {\n        const [code] = invalidIdentifierSubfieldCodes;\n        return {code, value};\n      }\n      return {code: idSub.code, value};\n    }\n\n    function normalizeHyphens(idSub) {\n      return {code: idSub.code, value: idSub.value.replace(/-/ug, '')};\n    }\n\n\n  }\n\n  function compare(a, b) {\n    debug(`Comparing A and B`);\n    if (a.length === 0 || b.length === 0) {\n      debugData(`No standardidentifiers (${identifier}) to compare`);\n      return 0;\n    }\n\n    debugData(`A: ${JSON.stringify(a)}`);\n    debugData(`B: ${JSON.stringify(b)}`);\n\n\n    if (bothHaveValidIdentifiers()) {\n      // Compare only valid identifiers, if both have valid idenfiers\n      const {maxValues, possibleMatchValues, matchingValues} = getValueCount(true);\n      if (matchingValues < 1) {\n        debug(`Both have valid standardidentifiers (${identifier}), but none of these match.`);\n        return -0.75;\n      }\n      debug(`Both have valid standardidentifiers (${identifier}), ${matchingValues}/${possibleMatchValues} valid identifiers match.`);\n      // ignore non-matches if there is mismatching amount of values\n      debug(`Possible matches: ${possibleMatchValues}/${maxValues}`);\n      //we give some kind of penalty for mismatching amount of values instead of simple divide?\n      const penaltyForMissing = 0.1 * (maxValues - possibleMatchValues);\n      const penaltyForMisMatch = 0.2 * (possibleMatchValues - matchingValues);\n      debug(`\\t points: penaltyForMissing: ${penaltyForMissing}`);\n      debug(`\\t points: penaltyForMisMatch: ${penaltyForMisMatch}`);\n\n      return 0.75 - penaltyForMisMatch - penaltyForMissing;\n      //return matchingValues / possibleMatchValues * 0.75;\n    }\n    // If both do not have valid identifiers, compare all identifiers\n    const {maxValues, matchingValues} = getValueCount();\n    debug(`Both do NOT have valid standardidentifiers (${identifier}), ${matchingValues}/${maxValues} valid/invalid identifiers match.`);\n\n    return matchingValues / maxValues * 0.2;\n\n    function bothHaveValidIdentifiers() {\n      const aValues = a.filter(({code}) => validIdentifierSubfieldCodes.includes(code));\n      const bValues = a.filter(({code}) => validIdentifierSubfieldCodes.includes(code));\n      debug(`A: ${aValues.length} valid ${identifier} identifiers`);\n      debug(`B: ${bValues.length} valid ${identifier} identifiers`);\n      return aValues.length > 0 && bValues.length > 0;\n    }\n\n    function getValueCount(validOnly = false) {\n      const aValues = getIdentifiers(a, validOnly);\n      const bValues = getIdentifiers(b, validOnly);\n\n      const matchingValues = getMatchingValuesAmount(aValues, bValues);\n\n      return {\n        maxValues: aValues.length > bValues.length ? aValues.length : bValues.length,\n        // possibleMatchingValues: amount of identifiers in set of less identifiers (we cannot more values than these)\n        possibleMatchValues: aValues.length > bValues.length ? bValues.length : aValues.length,\n        matchingValues\n      };\n\n      function getMatchingValuesAmount(aValues, bValues) {\n        if (bValues.length > aValues.length) {\n          return aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;\n        }\n        if (aValues.length > bValues.length) {\n          return bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;\n        }\n\n        // If we have same amount of values, we'll check matches both ways, to avoid mixups in cases\n        // there would be duplicate values\n        const aToB = aValues.filter(aValue => bValues.some(bValue => aValue === bValue)).length;\n        const bToA = bValues.filter(bValue => aValues.some(aValue => bValue === aValue)).length;\n\n        return aToB < bToA ? aToB : bToA;\n      }\n\n      function getIdentifiers(values, validOnly) {\n        if (validOnly) {\n          return values\n            .filter(({code}) => validIdentifierSubfieldCodes.includes(code))\n            .map(({value}) => value);\n        }\n\n        return values.map(({value}) => value);\n      }\n    }\n  }\n};\n"],
+  "mappings": "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",
+  "names": ["validatorAndNormalizer", "validIdentifierSubfieldCodes", "invalidIdentifierSubfieldCodes", "maxValues", "matchingValues", "aValues", "bValues", "validOnly"]
+}

package/dist/match-detection/features/bib/title-version-original.js

@@ -1,65 +1,24 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _debug = _interopRequireDefault(require("debug"));
-var _natural = require("natural");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
-*
-* @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)
-*
-* 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.
-*
-*/
-var _default = ({
-  treshold = 10
-} = {}) => ({
-  name: 'titleVersionOriginal',
-  extract: ({
-    record
-  }) => {
+import createDebugLogger from "debug";
+import naturalPkg from "natural";
+const { LevenshteinDistance: leven } = naturalPkg;
+export default ({ treshold = 10 } = {}) => ({
+  name: "titleVersionOriginal",
+  extract: ({ record }) => {
     const title = getTitle();
     if (title) {
-      return [title.replace(/[^\p{Letter}\p{Number}]/gu, '').toLowerCase()];
+      return [title.replace(/[^\p{Letter}\p{Number}]/gu, "").toLowerCase()];
     }
     return [];
     function getTitle() {
       const [field] = record.get(/^245$/u);
       if (field) {
-        return field.subfields.filter(({
-          code
-        }) => ['a', 'b'].includes(code)).map(({
-          value
-        }) => value).join('');
+        return field.subfields.filter(({ code }) => ["a", "b"].includes(code)).map(({ value }) => value).join("");
       }
     }
   },
   compare: (a, b) => {
-    const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:match-detection:features/bib/title-version-original');
-    const distance = (0, _natural.LevenshteinDistance)(a[0], b[0]);
+    const debug = createDebugLogger("@natlibfi/melinda-record-matching:match-detection:features/bib/title-version-original");
+    const distance = leven(a[0], b[0]);
     if (distance === 0) {
       return 0.5;
     }
@@ -75,5 +34,4 @@ var _default = ({
     }
   }
 });
-exports.default = _default;
-//# sourceMappingURL=title-version-original.js.map
+//# sourceMappingURL=title-version-original.js.map

package/dist/match-detection/features/bib/title-version-original.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"title-version-original.js","names":["_debug","_interopRequireDefault","require","_natural","obj","__esModule","default","_default","treshold","name","extract","record","title","getTitle","replace","toLowerCase","field","get","subfields","filter","code","includes","map","value","join","compare","a","b","debug","createDebugLogger","distance","leven","maxLength","getMaxLength","percentage","length","exports"],"sources":["../../../../src/match-detection/features/bib/title-version-original.js"],"sourcesContent":["/**\n*\n* @licstart  The following is the entire license notice for the JavaScript code in this file.\n*\n* Melinda record matching modules for Javascript\n*\n* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)\n*\n* This file is part of melinda-record-matching-js\n*\n* melinda-record-matching-js program is free software: you can redistribute it and/or modify\n* it under the terms of the GNU Lesser General Public License as\n* published by the Free Software Foundation, either version 3 of the\n* License, or (at your option) any later version.\n*\n* melinda-record-matching-js is distributed in the hope that it will be useful,\n* but WITHOUT ANY WARRANTY; without even the implied warranty of\n* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n* GNU Lesser General Public License for more details.\n*\n* You should have received a copy of the GNU Affero General Public License\n* along with this program.  If not, see <http://www.gnu.org/licenses/>.\n*\n* @licend  The above is the entire license notice\n* for the JavaScript code in this file.\n*\n*/\n\nimport createDebugLogger from 'debug';\nimport {LevenshteinDistance as leven} from 'natural';\n\nexport default ({treshold = 10} = {}) => ({\n  name: 'titleVersionOriginal',\n  extract: ({record}) => {\n    const title = getTitle();\n\n    if (title) {\n      return [title.replace(/[^\\p{Letter}\\p{Number}]/gu, '').toLowerCase()];\n    }\n\n    return [];\n\n    function getTitle() {\n      const [field] = record.get(/^245$/u);\n\n      if (field) {\n        return field.subfields\n          .filter(({code}) => ['a', 'b'].includes(code))\n          .map(({value}) => value)\n          .join('');\n      }\n    }\n  },\n  compare: (a, b) => {\n    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/title-version-original');\n    const distance = leven(a[0], b[0]);\n\n    if (distance === 0) {\n      return 0.5;\n    }\n\n    const maxLength = getMaxLength();\n    const percentage = distance / maxLength * 100;\n\n    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);\n\n    if (percentage <= treshold) {\n      return 0.3;\n    }\n\n    return -0.5;\n\n    function getMaxLength() {\n      return a[0].length > b[0].length ? a[0].length : b[0].length;\n    }\n\n  }\n});\n"],"mappings":";;;;;;AA4BA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAAqD,SAAAD,uBAAAG,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AA7BrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA1BA,IAAAG,QAAA,GA+BeA,CAAC;EAACC,QAAQ,GAAG;AAAE,CAAC,GAAG,CAAC,CAAC,MAAM;EACxCC,IAAI,EAAE,sBAAsB;EAC5BC,OAAO,EAAEA,CAAC;IAACC;EAAM,CAAC,KAAK;IACrB,MAAMC,KAAK,GAAGC,QAAQ,CAAC,CAAC;IAExB,IAAID,KAAK,EAAE;MACT,OAAO,CAACA,KAAK,CAACE,OAAO,CAAC,2BAA2B,EAAE,EAAE,CAAC,CAACC,WAAW,CAAC,CAAC,CAAC;IACvE;IAEA,OAAO,EAAE;IAET,SAASF,QAAQA,CAAA,EAAG;MAClB,MAAM,CAACG,KAAK,CAAC,GAAGL,MAAM,CAACM,GAAG,CAAC,QAAQ,CAAC;MAEpC,IAAID,KAAK,EAAE;QACT,OAAOA,KAAK,CAACE,SAAS,CACnBC,MAAM,CAAC,CAAC;UAACC;QAAI,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAACC,QAAQ,CAACD,IAAI,CAAC,CAAC,CAC7CE,GAAG,CAAC,CAAC;UAACC;QAAK,CAAC,KAAKA,KAAK,CAAC,CACvBC,IAAI,CAAC,EAAE,CAAC;MACb;IACF;EACF,CAAC;EACDC,OAAO,EAAEA,CAACC,CAAC,EAAEC,CAAC,KAAK;IACjB,MAAMC,KAAK,GAAG,IAAAC,cAAiB,EAAC,uFAAuF,CAAC;IACxH,MAAMC,QAAQ,GAAG,IAAAC,4BAAK,EAACL,CAAC,CAAC,CAAC,CAAC,EAAEC,CAAC,CAAC,CAAC,CAAC,CAAC;IAElC,IAAIG,QAAQ,KAAK,CAAC,EAAE;MAClB,OAAO,GAAG;IACZ;IAEA,MAAME,SAAS,GAAGC,YAAY,CAAC,CAAC;IAChC,MAAMC,UAAU,GAAGJ,QAAQ,GAAGE,SAAS,GAAG,GAAG;IAE7CJ,KAAK,CAAE,IAAGF,CAAE,SAAQC,CAAE,mBAAkBK,SAAU,gBAAeF,QAAS,kBAAiBI,UAAW,EAAC,CAAC;IAExG,IAAIA,UAAU,IAAI1B,QAAQ,EAAE;MAC1B,OAAO,GAAG;IACZ;IAEA,OAAO,CAAC,GAAG;IAEX,SAASyB,YAAYA,CAAA,EAAG;MACtB,OAAOP,CAAC,CAAC,CAAC,CAAC,CAACS,MAAM,GAAGR,CAAC,CAAC,CAAC,CAAC,CAACQ,MAAM,GAAGT,CAAC,CAAC,CAAC,CAAC,CAACS,MAAM,GAAGR,CAAC,CAAC,CAAC,CAAC,CAACQ,MAAM;IAC9D;EAEF;AACF,CAAC,CAAC;AAAAC,OAAA,CAAA9B,OAAA,GAAAC,QAAA"}
+{
+  "version": 3,
+  "sources": ["../../../../src/match-detection/features/bib/title-version-original.js"],
+  "sourcesContent": ["\nimport createDebugLogger from 'debug';\nimport naturalPkg from 'natural';\nconst {LevenshteinDistance: leven} = naturalPkg;\n\nexport default ({treshold = 10} = {}) => ({\n  name: 'titleVersionOriginal',\n  extract: ({record}) => {\n    const title = getTitle();\n\n    if (title) {\n      return [title.replace(/[^\\p{Letter}\\p{Number}]/gu, '').toLowerCase()];\n    }\n\n    return [];\n\n    function getTitle() {\n      const [field] = record.get(/^245$/u);\n\n      if (field) {\n        return field.subfields\n          .filter(({code}) => ['a', 'b'].includes(code))\n          .map(({value}) => value)\n          .join('');\n      }\n    }\n  },\n  compare: (a, b) => {\n    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/title-version-original');\n    const distance = leven(a[0], b[0]);\n\n    if (distance === 0) {\n      return 0.5;\n    }\n\n    const maxLength = getMaxLength();\n    const percentage = distance / maxLength * 100;\n\n    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);\n\n    if (percentage <= treshold) {\n      return 0.3;\n    }\n\n    return -0.5;\n\n    function getMaxLength() {\n      return a[0].length > b[0].length ? a[0].length : b[0].length;\n    }\n\n  }\n});\n"],
+  "mappings": "AACA,OAAO,uBAAuB;AAC9B,OAAO,gBAAgB;AACvB,MAAM,EAAC,qBAAqB,MAAK,IAAI;AAErC,eAAe,CAAC,EAAC,WAAW,GAAE,IAAI,CAAC,OAAO;AAAA,EACxC,MAAM;AAAA,EACN,SAAS,CAAC,EAAC,OAAM,MAAM;AACrB,UAAM,QAAQ,SAAS;AAEvB,QAAI,OAAO;AACT,aAAO,CAAC,MAAM,QAAQ,6BAA6B,EAAE,EAAE,YAAY,CAAC;AAAA,IACtE;AAEA,WAAO,CAAC;AAER,aAAS,WAAW;AAClB,YAAM,CAAC,KAAK,IAAI,OAAO,IAAI,QAAQ;AAEnC,UAAI,OAAO;AACT,eAAO,MAAM,UACV,OAAO,CAAC,EAAC,KAAI,MAAM,CAAC,KAAK,GAAG,EAAE,SAAS,IAAI,CAAC,EAC5C,IAAI,CAAC,EAAC,MAAK,MAAM,KAAK,EACtB,KAAK,EAAE;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AAAA,EACA,SAAS,CAAC,GAAG,MAAM;AACjB,UAAM,QAAQ,kBAAkB,uFAAuF;AACvH,UAAM,WAAW,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAEjC,QAAI,aAAa,GAAG;AAClB,aAAO;AAAA,IACT;AAEA,UAAM,YAAY,aAAa;AAC/B,UAAM,aAAa,WAAW,YAAY;AAE1C,UAAM,IAAI,CAAC,SAAS,CAAC,mBAAmB,SAAS,gBAAgB,QAAQ,kBAAkB,UAAU,EAAE;AAEvG,QAAI,cAAc,UAAU;AAC1B,aAAO;AAAA,IACT;AAEA,WAAO;AAEP,aAAS,eAAe;AACtB,aAAO,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE;AAAA,IACxD;AAAA,EAEF;AACF;",
+  "names": []
+}

package/dist/match-detection/features/bib/title.js

@@ -1,90 +1,39 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _natural = require("natural");
-var _matchingUtils = require("../../../matching-utils");
-var _debug = _interopRequireDefault(require("debug"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
-*
-* @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.
-*
-*/
-
-const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:match-detection:features:title');
-const debugData = debug.extend('data');
-var _default = ({
-  treshold = 10
-} = {}) => ({
-  name: 'Title',
-  extract: ({
-    record,
-    recordExternal
-  }) => {
-    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';
+import createDebugLogger from "debug";
+import naturalPkg from "natural";
+const { LevenshteinDistance: leven } = naturalPkg;
+import { testStringOrNumber } from "../../../matching-utils.js";
+const debug = createDebugLogger("@natlibfi/melinda-record-matching:match-detection:features:title");
+const debugData = debug.extend("data");
+export default ({ treshold = 10 } = {}) => ({
+  name: "Title",
+  extract: ({ record, recordExternal }) => {
+    const label = recordExternal && recordExternal.label ? recordExternal.label : "record";
     const title = getTitle();
-    debug(`${label} title: ${title}`);
-    if ((0, _matchingUtils.testStringOrNumber)(title)) {
-      const titleAsNormalizedString = String(title)
-      // decompose unicode diacritics
-      .normalize('NFD')
-      // strip non-letters/numbers
-      // - note: combined with decomposing unicode diactics this normalizes both 'saa' and 'sää' as 'saa'
-      // - we could precompose the finnish letters back to avoid this
-      .replace(/[^\p{Letter}\p{Number}]/gu, '').toLowerCase();
-      debug(`${label} titleString: ${titleAsNormalizedString}`);
+    debug(`${label}: title: ${title}`);
+    if (testStringOrNumber(title)) {
+      const titleAsNormalizedString = String(title).normalize("NFD").replace(/[^\p{Letter}\p{Number}]/gu, "").toLowerCase();
+      debug(`${label}: titleString: ${titleAsNormalizedString}`);
       return [titleAsNormalizedString];
     }
     return [];
     function getTitle() {
       const [field] = record.get(/^245$/u);
-      debugData(`${label} titleField: ${JSON.stringify(field)}`);
+      debugData(`${label}: titleField: ${JSON.stringify(field)}`);
       if (field) {
-        return field.subfields
-        // get also $n:s and $p:s here
-        .filter(({
-          code
-        }) => ['a', 'b', 'n', 'p'].includes(code)).map(({
-          value
-        }) => (0, _matchingUtils.testStringOrNumber)(value) ? String(value) : '').join('');
+        return field.subfields.filter(({ code }) => ["a", "b", "n", "p"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").join("");
       }
       return false;
     }
   },
   compare: (a, b) => {
-    const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:match-detection:features/bib/title');
-    const distance = (0, _natural.LevenshteinDistance)(a[0], b[0]);
+    const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:match-detection:features/bib/title");
+    const distance = leven(a[0], b[0]);
     if (distance === 0) {
       return 0.5;
     }
     const maxLength = getMaxLength();
     const percentage = distance / maxLength * 100;
-    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);
+    debug2(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);
     if (percentage <= treshold) {
       return 0.3;
     }
@@ -94,5 +43,4 @@ var _default = ({
     }
   }
 });
-exports.default = _default;
-//# sourceMappingURL=title.js.map
+//# sourceMappingURL=title.js.map

package/dist/match-detection/features/bib/title.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"title.js","names":["_natural","require","_matchingUtils","_debug","_interopRequireDefault","obj","__esModule","default","debug","createDebugLogger","debugData","extend","_default","treshold","name","extract","record","recordExternal","label","title","getTitle","testStringOrNumber","titleAsNormalizedString","String","normalize","replace","toLowerCase","field","get","JSON","stringify","subfields","filter","code","includes","map","value","join","compare","a","b","distance","leven","maxLength","getMaxLength","percentage","length","exports"],"sources":["../../../../src/match-detection/features/bib/title.js"],"sourcesContent":["/**\n*\n* @licstart  The following is the entire license notice for the JavaScript code in this file.\n*\n* Melinda record matching modules for Javascript\n*\n* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)\n*\n* This file is part of melinda-record-matching-js\n*\n* melinda-record-matching-js program is free software: you can redistribute it and/or modify\n* it under the terms of the GNU Lesser General Public License as\n* published by the Free Software Foundation, either version 3 of the\n* License, or (at your option) any later version.\n*\n* melinda-record-matching-js is distributed in the hope that it will be useful,\n* but WITHOUT ANY WARRANTY; without even the implied warranty of\n* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n* GNU Lesser General Public License for more details.\n*\n* You should have received a copy of the GNU Affero General Public License\n* along with this program.  If not, see <http://www.gnu.org/licenses/>.\n*\n* @licend  The above is the entire license notice\n* for the JavaScript code in this file.\n*\n*/\n\n\nimport {LevenshteinDistance as leven} from 'natural';\nimport {testStringOrNumber} from '../../../matching-utils';\nimport createDebugLogger from 'debug';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:title');\nconst debugData = debug.extend('data');\n\n\nexport default ({treshold = 10} = {}) => ({\n  name: 'Title',\n  extract: ({record, recordExternal}) => {\n    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';\n    const title = getTitle();\n    debug(`${label} title: ${title}`);\n\n    if (testStringOrNumber(title)) {\n      const titleAsNormalizedString = String(title)\n        // decompose unicode diacritics\n        .normalize('NFD')\n        // strip non-letters/numbers\n        // - note: combined with decomposing unicode diactics this normalizes both 'saa' and 'sää' as 'saa'\n        // - we could precompose the finnish letters back to avoid this\n        .replace(/[^\\p{Letter}\\p{Number}]/gu, '')\n        .toLowerCase();\n      debug(`${label} titleString: ${titleAsNormalizedString}`);\n      return [titleAsNormalizedString];\n    }\n\n    return [];\n\n    function getTitle() {\n      const [field] = record.get(/^245$/u);\n      debugData(`${label} titleField: ${JSON.stringify(field)}`);\n\n      if (field) {\n        return field.subfields\n          // get also $n:s and $p:s here\n          .filter(({code}) => ['a', 'b', 'n', 'p'].includes(code))\n          .map(({value}) => testStringOrNumber(value) ? String(value) : '')\n          .join('');\n      }\n      return false;\n    }\n  },\n  compare: (a, b) => {\n    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/title');\n    const distance = leven(a[0], b[0]);\n\n    if (distance === 0) {\n      return 0.5;\n    }\n\n    const maxLength = getMaxLength();\n    const percentage = distance / maxLength * 100;\n\n    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);\n\n    if (percentage <= treshold) {\n      return 0.3;\n    }\n\n    return -0.5;\n\n    function getMaxLength() {\n      return a[0].length > b[0].length ? a[0].length : b[0].length;\n    }\n\n  }\n});\n"],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../../../../src/match-detection/features/bib/title.js"],
+  "sourcesContent": ["import createDebugLogger from 'debug';\nimport naturalPkg from 'natural';\nconst {LevenshteinDistance: leven} = naturalPkg;\nimport {testStringOrNumber} from '../../../matching-utils.js';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:title');\nconst debugData = debug.extend('data');\n\n\nexport default ({treshold = 10} = {}) => ({\n  name: 'Title',\n  extract: ({record, recordExternal}) => {\n    const label = recordExternal && recordExternal.label ? recordExternal.label : 'record';\n    const title = getTitle();\n    debug(`${label}: title: ${title}`);\n\n    if (testStringOrNumber(title)) {\n      const titleAsNormalizedString = String(title)\n        // decompose unicode diacritics\n        .normalize('NFD')\n        // strip non-letters/numbers\n        // - note: combined with decomposing unicode diactics this normalizes both 'saa' and 's\u00E4\u00E4' as 'saa'\n        // - we could precompose the finnish letters back to avoid this\n        .replace(/[^\\p{Letter}\\p{Number}]/gu, '')\n        .toLowerCase();\n      debug(`${label}: titleString: ${titleAsNormalizedString}`);\n      return [titleAsNormalizedString];\n    }\n\n    return [];\n\n    function getTitle() {\n      const [field] = record.get(/^245$/u);\n      debugData(`${label}: titleField: ${JSON.stringify(field)}`);\n\n      if (field) {\n        return field.subfields\n          // get also $n:s and $p:s here\n          .filter(({code}) => ['a', 'b', 'n', 'p'].includes(code))\n          .map(({value}) => testStringOrNumber(value) ? String(value) : '')\n          .join('');\n      }\n      return false;\n    }\n  },\n  compare: (a, b) => {\n    const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features/bib/title');\n    const distance = leven(a[0], b[0]);\n\n    if (distance === 0) {\n      return 0.5;\n    }\n\n    const maxLength = getMaxLength();\n    const percentage = distance / maxLength * 100;\n\n    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);\n\n    if (percentage <= treshold) {\n      return 0.3;\n    }\n\n    return -0.5;\n\n    function getMaxLength() {\n      return a[0].length > b[0].length ? a[0].length : b[0].length;\n    }\n\n  }\n});\n"],
+  "mappings": "AAAA,OAAO,uBAAuB;AAC9B,OAAO,gBAAgB;AACvB,MAAM,EAAC,qBAAqB,MAAK,IAAI;AACrC,SAAQ,0BAAyB;AAEjC,MAAM,QAAQ,kBAAkB,kEAAkE;AAClG,MAAM,YAAY,MAAM,OAAO,MAAM;AAGrC,eAAe,CAAC,EAAC,WAAW,GAAE,IAAI,CAAC,OAAO;AAAA,EACxC,MAAM;AAAA,EACN,SAAS,CAAC,EAAC,QAAQ,eAAc,MAAM;AACrC,UAAM,QAAQ,kBAAkB,eAAe,QAAQ,eAAe,QAAQ;AAC9E,UAAM,QAAQ,SAAS;AACvB,UAAM,GAAG,KAAK,YAAY,KAAK,EAAE;AAEjC,QAAI,mBAAmB,KAAK,GAAG;AAC7B,YAAM,0BAA0B,OAAO,KAAK,EAEzC,UAAU,KAAK,EAIf,QAAQ,6BAA6B,EAAE,EACvC,YAAY;AACf,YAAM,GAAG,KAAK,kBAAkB,uBAAuB,EAAE;AACzD,aAAO,CAAC,uBAAuB;AAAA,IACjC;AAEA,WAAO,CAAC;AAER,aAAS,WAAW;AAClB,YAAM,CAAC,KAAK,IAAI,OAAO,IAAI,QAAQ;AACnC,gBAAU,GAAG,KAAK,iBAAiB,KAAK,UAAU,KAAK,CAAC,EAAE;AAE1D,UAAI,OAAO;AACT,eAAO,MAAM,UAEV,OAAO,CAAC,EAAC,KAAI,MAAM,CAAC,KAAK,KAAK,KAAK,GAAG,EAAE,SAAS,IAAI,CAAC,EACtD,IAAI,CAAC,EAAC,MAAK,MAAM,mBAAmB,KAAK,IAAI,OAAO,KAAK,IAAI,EAAE,EAC/D,KAAK,EAAE;AAAA,MACZ;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EACA,SAAS,CAAC,GAAG,MAAM;AACjB,UAAMA,SAAQ,kBAAkB,sEAAsE;AACtG,UAAM,WAAW,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAEjC,QAAI,aAAa,GAAG;AAClB,aAAO;AAAA,IACT;AAEA,UAAM,YAAY,aAAa;AAC/B,UAAM,aAAa,WAAW,YAAY;AAE1C,IAAAA,OAAM,IAAI,CAAC,SAAS,CAAC,mBAAmB,SAAS,gBAAgB,QAAQ,kBAAkB,UAAU,EAAE;AAEvG,QAAI,cAAc,UAAU;AAC1B,aAAO;AAAA,IACT;AAEA,WAAO;AAEP,aAAS,eAAe;AACtB,aAAO,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE;AAAA,IACxD;AAAA,EAEF;AACF;",
+  "names": ["debug"]
+}

package/dist/match-detection/features/index.js

@@ -1,11 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.bib = void 0;
-var bib = _interopRequireWildcard(require("./bib"));
-exports.bib = bib;
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-//# sourceMappingURL=index.js.map
+import * as bib from "./bib/index.js";
+export { bib };
+//# sourceMappingURL=index.js.map