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

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

@@ -0,0 +1,99 @@
+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 `);
+    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 = uniqueSubfields(validatedAndNormalizedIdentifiers);
+    debugData(`${label}: Unique IDs from fields (${identifiers.length}): ${JSON.stringify(identifiers)}`);
+    return identifiers;
+    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));
+    }
+    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 };
+    }
+    function normalizeHyphens(idSub) {
+      return { code: idSub.code, value: idSub.value.replace(/-/ug, "") };
+    }
+  }
+  function compare(a, b) {
+    debug(`Comparing A and B`);
+    if (a.length === 0 || b.length === 0) {
+      debugData(`No standardidentifiers (${identifier}) to compare`);
+      return 0;
+    }
+    debugData(`A: ${JSON.stringify(a)}`);
+    debugData(`B: ${JSON.stringify(b)}`);
+    if (bothHaveValidIdentifiers()) {
+      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}), ${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;
+    }
+    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));
+      debug(`A: ${aValues.length} valid ${identifier} identifiers`);
+      debug(`B: ${bValues.length} valid ${identifier} identifiers`);
+      return aValues.length > 0 && bValues.length > 0;
+    }
+    function getValueCount(validOnly = false) {
+      const aValues = getIdentifiers(a, validOnly);
+      const bValues = getIdentifiers(b, validOnly);
+      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: matchingValues2
+      };
+      function getMatchingValuesAmount(aValues2, bValues2) {
+        if (bValues2.length > aValues2.length) {
+          return aValues2.filter((aValue) => bValues2.some((bValue) => aValue === bValue)).length;
+        }
+        if (aValues2.length > bValues2.length) {
+          return bValues2.filter((bValue) => aValues2.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, validOnly2) {
+        if (validOnly2) {
+          return values.filter(({ code }) => validIdentifierSubfieldCodes.includes(code)).map(({ value }) => value);
+        }
+        return values.map(({ value }) => value);
+      }
+    }
+  }
+};
+//# sourceMappingURL=standard-identifier-factory.js.map

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

@@ -0,0 +1,7 @@
+{
+  "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

@@ -0,0 +1,37 @@
+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 [];
+    function getTitle() {
+      const [field] = record.get(/^245$/u);
+      if (field) {
+        return field.subfields.filter(({ code }) => ["a", "b"].includes(code)).map(({ value }) => value).join("");
+      }
+    }
+  },
+  compare: (a, b) => {
+    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;
+    }
+    const maxLength = getMaxLength();
+    const percentage = distance / maxLength * 100;
+    debug(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);
+    if (percentage <= treshold) {
+      return 0.3;
+    }
+    return -0.5;
+    function getMaxLength() {
+      return a[0].length > b[0].length ? a[0].length : b[0].length;
+    }
+  }
+});
+//# sourceMappingURL=title-version-original.js.map

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

@@ -0,0 +1,7 @@
+{
+  "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

@@ -0,0 +1,46 @@
+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 (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)}`);
+      if (field) {
+        return field.subfields.filter(({ code }) => ["a", "b", "n", "p"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").join("");
+      }
+      return false;
+    }
+  },
+  compare: (a, b) => {
+    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;
+    debug2(`'${a}' vs '${b}': Max length = ${maxLength}, distance = ${distance}, percentage = ${percentage}`);
+    if (percentage <= treshold) {
+      return 0.3;
+    }
+    return -0.5;
+    function getMaxLength() {
+      return a[0].length > b[0].length ? a[0].length : b[0].length;
+    }
+  }
+});
+//# sourceMappingURL=title.js.map

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

@@ -0,0 +1,7 @@
+{
+  "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

@@ -0,0 +1,3 @@
+import * as bib from "./bib/index.js";
+export { bib };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/match-detection/features/index.js"],
+  "sourcesContent": ["\nimport * as bib from './bib/index.js';\nexport {bib};\n"],
+  "mappings": "AACA,YAAY,SAAS;AACrB,SAAQ;",
+  "names": []
+}

package/dist/match-detection/index.js

@@ -0,0 +1,86 @@
+import createDebugLogger from "debug";
+import * as features from "./features/index.js";
+export { features };
+export default ({ strategy, treshold = 0.9 }, returnStrategy = false, localSettings = {}) => ({ recordA, recordB, recordAExternal = {}, recordBExternal = {} }) => {
+  const minProbabilityQuantifier = 0.5;
+  const debug = createDebugLogger("@natlibfi/melinda-record-matching:match-detection");
+  const debugData = debug.extend("data");
+  debugData(`Strategy: ${JSON.stringify(strategy)}, Treshold: ${JSON.stringify(treshold)}, ReturnStrategy: ${JSON.stringify(returnStrategy)}`);
+  debugData(`Records: A: ${recordA}
+B: ${recordB}`);
+  debug(`Externals: A: ${JSON.stringify(recordAExternal)}, B: ${JSON.stringify(recordBExternal)}`);
+  const featuresA = extractFeatures({ record: recordA, recordExternal: recordAExternal, localSettings });
+  debug(`We got an array of records: ${Array.isArray(recordB)}`);
+  const recordsB = Array.isArray(recordB) ? recordB : [recordB];
+  const recordsBExternal = Array.isArray(recordB) ? recordBExternal : [recordBExternal];
+  const detectionResults = recordsB.map((record, index) => actualDetection({ featuresA, recordAExternal, record, recordExternal: recordsBExternal[index], index }));
+  return Array.isArray(recordB) ? detectionResults : detectionResults[0];
+  function actualDetection({ featuresA: featuresA2, record, recordExternal, index, localSettings: localSettings2 }) {
+    const labelA = recordAExternal && recordAExternal.label ? recordAExternal.label : "a";
+    const labelB = recordExternal && recordExternal.label ? recordExternal.label : "b";
+    debug(`Actual detection for record ${index + 1} ${labelB}`);
+    const featuresB = extractFeatures({ record, recordExternal, localSettings: localSettings2 });
+    debugData(`Features (a: ${labelA}): ${JSON.stringify(featuresA2)}`);
+    debugData(`Features (b: ${labelB}): ${JSON.stringify(featuresB)}`);
+    const featurePairs = generateFeaturePairs(featuresA2, featuresB);
+    const similarityVector = generateSimilarityVector(featurePairs);
+    if (similarityVector.some((v) => v >= minProbabilityQuantifier)) {
+      const probability = calculateProbability(similarityVector);
+      debug(`probability: ${probability} (Treshold: ${treshold})`);
+      return returnResult({ match: probability >= treshold, probability });
+    }
+    debugData(`No feature yielded minimum probability amount of points (${minProbabilityQuantifier})`);
+    return returnResult({ match: false, probability: 0 });
+  }
+  function extractFeatures({ record, recordExternal }) {
+    return strategy.reduce((acc, { name, extract }) => acc.concat({ name, value: extract({ record, recordExternal }) }), []);
+  }
+  function returnResult(result) {
+    if (returnStrategy) {
+      debug(`Returning detection strategy with the result`);
+      const resultWithStrategy = { match: result.match, probability: result.probability, strategy: formatStrategy(strategy), treshold };
+      debugData(`${JSON.stringify(resultWithStrategy)}`);
+      return resultWithStrategy;
+    }
+    return result;
+  }
+  function formatStrategy(strategy2) {
+    const strategyNames = strategy2.map((element) => element.name);
+    return strategyNames || [];
+  }
+  function calculateProbability(similarityVector) {
+    const probability = similarityVector.reduce((acc, v) => acc + v, 0);
+    return probability > 1 ? 1 : probability;
+  }
+  function generateSimilarityVector(featurePairs) {
+    const compared = featurePairs.map(({ name, a, b }) => {
+      const { compare } = strategy.find(({ name: featureName }) => name === featureName);
+      const points = compare(a, b);
+      return { name, points };
+    });
+    debugData(`Points: ${JSON.stringify(compared)}`);
+    return compared.map(({ points }) => points);
+  }
+  function generateFeaturePairs(featuresA2, featuresB) {
+    const pairs = generatePairs();
+    const missingFeatures = findMissing();
+    debug(`Not comparing the following features because one, or both records are missing features: ${JSON.stringify(missingFeatures)}`);
+    return pairs;
+    function generatePairs() {
+      return featuresA2.reduce((acc, { name, value }, index) => acc.concat({
+        name,
+        a: value,
+        b: featuresB[index].value
+      }), []).filter(({ a, b }) => {
+        if (a.length === 0 || b.length === 0) {
+          return false;
+        }
+        return true;
+      });
+    }
+    function findMissing() {
+      return featuresA2.map(({ name }) => name).filter((v) => pairs.some(({ name }) => name === v) === false);
+    }
+  }
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/match-detection/index.js"],
+  "sourcesContent": ["\nimport createDebugLogger from 'debug';\nimport * as features from './features/index.js';\n\nexport {features};\n\nexport default ({strategy, treshold = 0.9}, returnStrategy = false, localSettings = {}) => ({recordA, recordB, recordAExternal = {}, recordBExternal = {}}) => {\n  const minProbabilityQuantifier = 0.5;\n\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection');\n  const debugData = debug.extend('data');\n\n  debugData(`Strategy: ${JSON.stringify(strategy)}, Treshold: ${JSON.stringify(treshold)}, ReturnStrategy: ${JSON.stringify(returnStrategy)}`);\n  debugData(`Records: A: ${recordA}\\nB: ${recordB}`);\n  debug(`Externals: A: ${JSON.stringify(recordAExternal)}, B: ${JSON.stringify(recordBExternal)}`);\n  // We could add here labels for records if we didn't get external labels\n\n  const featuresA = extractFeatures({record: recordA, recordExternal: recordAExternal, localSettings});\n\n  debug(`We got an array of records: ${Array.isArray(recordB)}`);\n  const recordsB = Array.isArray(recordB) ? recordB : [recordB];\n  const recordsBExternal = Array.isArray(recordB) ? recordBExternal : [recordBExternal];\n\n  const detectionResults = recordsB.map((record, index) => actualDetection({featuresA, recordAExternal, record, recordExternal: recordsBExternal[index], index}));\n\n  // if we got array of records, we return an array of result\n  // if we got a singular record, we return a singular result\n  return Array.isArray(recordB) ? detectionResults : detectionResults[0];\n\n  function actualDetection({featuresA, record, recordExternal, index, localSettings}) {\n    const labelA = recordAExternal && recordAExternal.label ? recordAExternal.label : 'a';\n    const labelB = recordExternal && recordExternal.label ? recordExternal.label : 'b';\n\n\n    debug(`Actual detection for record ${index + 1} ${labelB}`);\n    const featuresB = extractFeatures({record, recordExternal, localSettings});\n\n    debugData(`Features (a: ${labelA}): ${JSON.stringify(featuresA)}`);\n    debugData(`Features (b: ${labelB}): ${JSON.stringify(featuresB)}`);\n\n    const featurePairs = generateFeaturePairs(featuresA, featuresB);\n    const similarityVector = generateSimilarityVector(featurePairs);\n\n    if (similarityVector.some(v => v >= minProbabilityQuantifier)) {\n      const probability = calculateProbability(similarityVector);\n      debug(`probability: ${probability} (Treshold: ${treshold})`);\n      return returnResult({match: probability >= treshold, probability});\n    }\n\n    debugData(`No feature yielded minimum probability amount of points (${minProbabilityQuantifier})`);\n    return returnResult({match: false, probability: 0.0});\n  }\n\n  function extractFeatures({record, recordExternal}) {\n    return strategy.reduce((acc, {name, extract}) => acc.concat({name, value: extract({record, recordExternal})}), []);\n  }\n\n  function returnResult(result) {\n    if (returnStrategy) {\n      debug(`Returning detection strategy with the result`);\n      const resultWithStrategy = {match: result.match, probability: result.probability, strategy: formatStrategy(strategy), treshold};\n      debugData(`${JSON.stringify(resultWithStrategy)}`);\n      return resultWithStrategy;\n    }\n    return result;\n  }\n\n  function formatStrategy(strategy) {\n    const strategyNames = strategy.map(element => element.name);\n    return strategyNames || [];\n  }\n\n  function calculateProbability(similarityVector) {\n    const probability = similarityVector.reduce((acc, v) => acc + v, 0.0);\n    return probability > 1.0 ? 1.0 : probability;\n  }\n\n  function generateSimilarityVector(featurePairs) {\n    const compared = featurePairs.map(({name, a, b}) => {\n      const {compare} = strategy.find(({name: featureName}) => name === featureName);\n      const points = compare(a, b);\n      return {name, points};\n    });\n\n    debugData(`Points: ${JSON.stringify(compared)}`);\n    return compared.map(({points}) => points);\n  }\n\n  function generateFeaturePairs(featuresA, featuresB) {\n    const pairs = generatePairs();\n    const missingFeatures = findMissing();\n\n    debug(`Not comparing the following features because one, or both records are missing features: ${JSON.stringify(missingFeatures)}`);\n    return pairs;\n\n    function generatePairs() {\n      return featuresA\n        .reduce((acc, {name, value}, index) => acc.concat({\n          name,\n          a: value,\n          b: featuresB[index].value\n        }), [])\n        .filter(({a, b}) => {\n          if (a.length === 0 || b.length === 0) {\n            return false;\n          }\n\n          return true;\n        });\n    }\n\n    function findMissing() {\n      return featuresA\n        .map(({name}) => name)\n        .filter(v => pairs.some(({name}) => name === v) === false);\n    }\n  }\n\n};\n"],
+  "mappings": "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",
+  "names": ["featuresA", "localSettings", "strategy"]
+}

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

@@ -0,0 +1,44 @@
+import assert from "node:assert";
+import { describe } from "node:test";
+import createDebugLogger from "debug";
+import { inspect } from "util";
+import generateTests from "@natlibfi/fixugen";
+import { READERS } from "@natlibfi/fixura";
+import { MarcRecord } from "@natlibfi/marc-record";
+import createDetectionInterface from "./index.js";
+import * as features from "./features/index.js";
+const debug = createDebugLogger("@natlibfi/melinda-record-matching:match-detection:test");
+const debugData = debug.extend("data");
+describe("match-detection", () => {
+  generateTests({
+    path: [import.meta.dirname, "..", "..", "test-fixtures", "match-detection", "index"],
+    useMetadataFile: true,
+    recurse: false,
+    fixura: {
+      reader: READERS.JSON
+    },
+    callback: ({ getFixture, options, expectedResults, array, enabled = true }) => {
+      if (!enabled) {
+        debug(`*** DISABLED TEST! ***`);
+        return;
+      }
+      const detect = createDetectionInterface(formatOptions());
+      const recordA = new MarcRecord(getFixture("recordA.json"), { subfieldValues: false });
+      debugData(inspect(recordA));
+      debug(`Our recordB is an array of records: ${array}`);
+      const recordB = array ? getFixture("recordB.json").map((recordJson) => new MarcRecord(recordJson, { subfieldValues: false })) : new MarcRecord(getFixture("recordB.json"), { subfieldValues: false });
+      debugData(inspect(recordB));
+      const results = detect({ recordA, recordB });
+      debugData(`${JSON.stringify(results)}`);
+      assert.deepStrictEqual(results, expectedResults);
+      function formatOptions() {
+        const contextFeatures = features[options.strategy.type];
+        return {
+          ...options,
+          strategy: options.strategy.features.map((v) => contextFeatures[v]())
+        };
+      }
+    }
+  });
+});
+//# sourceMappingURL=index.test.js.map

package/dist/match-detection/index.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/match-detection/index.test.js"],
+  "sourcesContent": ["import assert from 'node:assert';\nimport {describe} from 'node:test';\nimport createDebugLogger from 'debug';\nimport {inspect} from 'util';\nimport generateTests from '@natlibfi/fixugen';\nimport {READERS} from '@natlibfi/fixura';\nimport {MarcRecord} from '@natlibfi/marc-record';\n\nimport createDetectionInterface from './index.js';\nimport * as features from './features/index.js';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:test');\nconst debugData = debug.extend('data');\n\ndescribe('match-detection', () => {\n  generateTests({\n    path: [import.meta.dirname, '..', '..', 'test-fixtures', 'match-detection', 'index'],\n    useMetadataFile: true,\n    recurse: false,\n    fixura: {\n      reader: READERS.JSON\n    },\n    callback: ({getFixture, options, expectedResults, array, enabled = true}) => {\n\n      if (!enabled) {\n        debug(`*** DISABLED TEST! ***`);\n        return;\n      }\n\n      const detect = createDetectionInterface(formatOptions());\n      const recordA = new MarcRecord(getFixture('recordA.json'), {subfieldValues: false});\n      debugData(inspect(recordA));\n\n      debug(`Our recordB is an array of records: ${array}`);\n      const recordB = array\n        ? getFixture('recordB.json').map(recordJson => new MarcRecord(recordJson, {subfieldValues: false}))\n        : new MarcRecord(getFixture('recordB.json'), {subfieldValues: false});\n      debugData(inspect(recordB));\n\n      const results = detect({recordA, recordB});\n      debugData(`${JSON.stringify(results)}`);\n\n      assert.deepStrictEqual(results, expectedResults);\n\n      function formatOptions() {\n        const contextFeatures = features[options.strategy.type];\n\n        return {\n          ...options,\n          strategy: options.strategy.features.map(v => contextFeatures[v]())\n        };\n      }\n    }\n  });\n});\n"],
+  "mappings": "AAAA,OAAO,YAAY;AACnB,SAAQ,gBAAe;AACvB,OAAO,uBAAuB;AAC9B,SAAQ,eAAc;AACtB,OAAO,mBAAmB;AAC1B,SAAQ,eAAc;AACtB,SAAQ,kBAAiB;AAEzB,OAAO,8BAA8B;AACrC,YAAY,cAAc;AAE1B,MAAM,QAAQ,kBAAkB,wDAAwD;AACxF,MAAM,YAAY,MAAM,OAAO,MAAM;AAErC,SAAS,mBAAmB,MAAM;AAChC,gBAAc;AAAA,IACZ,MAAM,CAAC,YAAY,SAAS,MAAM,MAAM,iBAAiB,mBAAmB,OAAO;AAAA,IACnF,iBAAiB;AAAA,IACjB,SAAS;AAAA,IACT,QAAQ;AAAA,MACN,QAAQ,QAAQ;AAAA,IAClB;AAAA,IACA,UAAU,CAAC,EAAC,YAAY,SAAS,iBAAiB,OAAO,UAAU,KAAI,MAAM;AAE3E,UAAI,CAAC,SAAS;AACZ,cAAM,wBAAwB;AAC9B;AAAA,MACF;AAEA,YAAM,SAAS,yBAAyB,cAAc,CAAC;AACvD,YAAM,UAAU,IAAI,WAAW,WAAW,cAAc,GAAG,EAAC,gBAAgB,MAAK,CAAC;AAClF,gBAAU,QAAQ,OAAO,CAAC;AAE1B,YAAM,uCAAuC,KAAK,EAAE;AACpD,YAAM,UAAU,QACZ,WAAW,cAAc,EAAE,IAAI,gBAAc,IAAI,WAAW,YAAY,EAAC,gBAAgB,MAAK,CAAC,CAAC,IAChG,IAAI,WAAW,WAAW,cAAc,GAAG,EAAC,gBAAgB,MAAK,CAAC;AACtE,gBAAU,QAAQ,OAAO,CAAC;AAE1B,YAAM,UAAU,OAAO,EAAC,SAAS,QAAO,CAAC;AACzC,gBAAU,GAAG,KAAK,UAAU,OAAO,CAAC,EAAE;AAEtC,aAAO,gBAAgB,SAAS,eAAe;AAE/C,eAAS,gBAAgB;AACvB,cAAM,kBAAkB,SAAS,QAAQ,SAAS,IAAI;AAEtD,eAAO;AAAA,UACL,GAAG;AAAA,UACH,UAAU,QAAQ,SAAS,SAAS,IAAI,OAAK,gBAAgB,CAAC,EAAE,CAAC;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/matching-utils.js

@@ -0,0 +1,79 @@
+import createDebugLogger from "debug";
+const debug = createDebugLogger("@natlibfi/melinda-record-matching:utils");
+const debugData = debug.extend("data");
+export function getMelindaIdsF035(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:melinda-id");
+  const debugData2 = debug2.extend("data");
+  const f035s = record.getFields("035");
+  if (f035s.length < 1) {
+    debug2(`No f035s found.`);
+    return [];
+  }
+  const allF035MelindaIds = [].concat(...f035s.map((field) => toMelindaIds(field)));
+  const f035MelindaIds = [...new Set(allF035MelindaIds)];
+  debugData2(`Fields (${f035s.length}): ${JSON.stringify(f035s)}`);
+  debugData2(`Ids (${allF035MelindaIds.length}): ${JSON.stringify(allF035MelindaIds)}`);
+  debugData2(`Unique ids (${f035MelindaIds.length}): ${JSON.stringify(f035MelindaIds)}`);
+  return f035MelindaIds;
+}
+export function toMelindaIds({ subfields }, subfieldsToParse = ["a", "z"]) {
+  const melindaIdRegExp = /^(?<prefix>\(FI-MELINDA\)|FCC)(?<id>\d{9})$/u;
+  return subfields.filter((sub) => subfieldsToParse.includes(sub.code)).filter((sub) => testStringOrNumber(sub.value) && melindaIdRegExp.test(String(sub.value))).map(({ value }) => testStringOrNumber(value) ? String(value).replace(melindaIdRegExp, "$<id>") : "");
+}
+export function validateSidFieldSubfieldCounts(field) {
+  debugData(`Validating SID field ${JSON.stringify(field)}`);
+  const countC = countSubfields(field, "c");
+  const countB = countSubfields(field, "b");
+  debug(`Found ${countC} sf $cs and ${countB} sf $bs. IsValid: ${countC === 1 && countB === 1}`);
+  return countC === 1 && countB === 1;
+}
+function countSubfields(field, subfieldCode) {
+  return field.subfields.filter(({ code }) => code === subfieldCode).length;
+}
+export function getSubfieldValues(field, subfieldCode) {
+  debugData(`Get subfield(s) $${subfieldCode} from ${JSON.stringify(field)}`);
+  return field.subfields.filter(({ code }) => code === subfieldCode).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value);
+}
+export function testStringOrNumber(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return true;
+  }
+  return false;
+}
+export function extractSubfieldsFromField(field, subfieldCodes) {
+  if (field === void 0 || field.subfields === void 0) {
+    return [];
+  }
+  const resultSubfields = field.subfields.filter(({ code }) => subfieldCodes.includes(code)).map(({ code, value }) => ({ code, value: testStringOrNumber(value) ? String(value) : "" })).filter((value) => value);
+  return resultSubfields;
+}
+export function uniqueSubfields(subfields) {
+  return subfields.reduce((arr, e) => {
+    if (!arr.find((item) => item.code === e.code && item.value === e.value)) {
+      const newArr = arr.concat(e);
+      return newArr;
+    }
+    return arr;
+  }, []);
+}
+export function getMatchCounts(aValues, bValues) {
+  const matchingValues = 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
+  };
+  function getMatchingValuesAmount(aValues2, bValues2) {
+    if (bValues2.length > aValues2.length) {
+      return aValues2.filter((aValue) => bValues2.some((bValue) => aValue === bValue)).length;
+    }
+    if (aValues2.length > bValues2.length) {
+      return bValues2.filter((bValue) => aValues2.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;
+  }
+}
+//# sourceMappingURL=matching-utils.js.map

package/dist/matching-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matching-utils.js"],
+  "sourcesContent": ["import createDebugLogger from 'debug';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:utils');\nconst debugData = debug.extend('data');\n\nexport function getMelindaIdsF035(record) {\n\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:melinda-id');\n  const debugData = debug.extend('data');\n\n  const f035s = record.getFields('035');\n\n  if (f035s.length < 1) {\n    debug(`No f035s found.`);\n    return [];\n  }\n\n  const allF035MelindaIds = [].concat(...f035s.map(field => toMelindaIds(field)));\n  const f035MelindaIds = [...new Set(allF035MelindaIds)];\n\n  debugData(`Fields (${f035s.length}): ${JSON.stringify(f035s)}`);\n  debugData(`Ids (${allF035MelindaIds.length}): ${JSON.stringify(allF035MelindaIds)}`);\n  debugData(`Unique ids (${f035MelindaIds.length}): ${JSON.stringify(f035MelindaIds)}`);\n\n  return f035MelindaIds;\n}\n\nexport function toMelindaIds({subfields}, subfieldsToParse = ['a', 'z']) {\n  const melindaIdRegExp = /^(?<prefix>\\(FI-MELINDA\\)|FCC)(?<id>\\d{9})$/u;\n\n  return subfields\n    .filter(sub => subfieldsToParse.includes(sub.code))\n    .filter(sub => testStringOrNumber(sub.value) && melindaIdRegExp.test(String(sub.value)))\n    .map(({value}) => testStringOrNumber(value) ? String(value).replace(melindaIdRegExp, '$<id>') : '');\n}\n\nexport function validateSidFieldSubfieldCounts(field) {\n  // Valid SID-fields have just one $c and one $b\n  debugData(`Validating SID field ${JSON.stringify(field)}`);\n  const countC = countSubfields(field, 'c');\n  const countB = countSubfields(field, 'b');\n  debug(`Found ${countC} sf $cs and ${countB} sf $bs. IsValid: ${countC === 1 && countB === 1}`);\n\n  return countC === 1 && countB === 1;\n}\n\nfunction countSubfields(field, subfieldCode) {\n  // debug(`Counting subfields ${subfieldCode}`);\n  return field.subfields.filter(({code}) => code === subfieldCode).length;\n}\n\nexport function getSubfieldValues(field, subfieldCode) {\n  debugData(`Get subfield(s) $${subfieldCode} from ${JSON.stringify(field)}`);\n  return field.subfields\n    .filter(({code}) => code === subfieldCode)\n    .map(({value}) => testStringOrNumber(value) ? String(value) : '')\n    .filter(value => value);\n}\n\nexport function testStringOrNumber(value) {\n  if (typeof value === 'string' || typeof value === 'number') {\n    return true;\n  }\n  return false;\n}\n\nexport function extractSubfieldsFromField(field, subfieldCodes) {\n  if (field === undefined || field.subfields === undefined) {\n    return [];\n  }\n  const resultSubfields = field.subfields\n    .filter(({code}) => subfieldCodes.includes(code))\n    .map(({code, value}) => ({code, value: testStringOrNumber(value) ? String(value) : ''}))\n    .filter(value => value);\n  return resultSubfields;\n}\n\nexport function uniqueSubfields(subfields) {\n  return subfields.reduce((arr, e) => {\n    if (!arr.find(item => item.code === e.code && item.value === e.value)) {\n      const newArr = arr.concat(e);\n      return newArr;\n    }\n    return arr;\n  }, []);\n}\n\nexport function getMatchCounts(aValues, bValues) {\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"],
+  "mappings": "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",
+  "names": ["debug", "debugData", "aValues", "bValues"]
+}

package/package.json

@@ -14,7 +14,7 @@
 		"url": "git@github.com:natlibfi/melinda-record-matching-js.git"
 	},
 	"license": "MIT",
-	"version": "5.0.0-alpha.1",
+	"version": "5.0.0-alpha.2",
 	"main": "./dist/index.js",
 	"type": "module",
 	"bin": "./dist/cli.js",
@@ -25,6 +25,7 @@
 		"access": "public"
 	},
 	"scripts": {
+		"prepare": "npm run build",
 		"start": "node dist/index.js",
 		"build": "esbuild \"src/**/*.js\" --sourcemap --platform=node --outdir=dist",
 		"cli": "node dist/cli.js",