@natlibfi/marc-record-merge 6.0.0-beta.2 → 6.0.0-beta.6

package/dist/reducers/copy.js

@@ -5,158 +5,359 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _marcRecord = require("@natlibfi/marc-record");
+
 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.
-*
-* Merge MARC records
-*
-* Copyright (C) 2015-2019 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of marc-record-merge-js
-
-* marc-record-merge-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.
-*
-* marc-record-merge-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 Lesser 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.
-*
-*/
-
-/**
- * Test 01: If base does not contain the field at all, it is copied from source to base
- * Test 02: Identical control fields are not copied
- * Test 03: Add missing control field to base
- * Test 04: Identical data fields in base and source, not copied
- * Test 05: Different data fields are copied from source to base (multiple fields)
- * Test 06: compareTagsOnly: Field is copied from source only if it is missing in base, a different instance is not copied
- * Test 07: excludeSubfields: Ignore excluded subfields in comparing identicalness
- * Test 08: dropSubfields: Drop subfields from source before copying
- * Test 09: compareTagsOnly for repeatable fields, 2x each 260/264
- * */
+/* eslint-disable max-statements */
+
+/* eslint-disable no-unused-vars */
 var _default = ({
   tagPattern,
   compareTagsOnly = false,
+  compareWithoutIndicators = false,
+  subfieldsMustBeIdentical = true,
   excludeSubfields = [],
-  dropSubfields = []
+  dropSubfields = [],
+  copyUnless = [],
+  baseValidators = {
+    subfieldValues: false
+  },
+  sourceValidators = {
+    subfieldValues: false
+  },
+  swapTag = [],
+  swapSubfieldCode = [],
+  doNotCopyIfFieldPresent = false
 }) => (base, source) => {
+  const baseRecord = new _marcRecord.MarcRecord(base, baseValidators);
+  const sourceRecord = new _marcRecord.MarcRecord(source, sourceValidators);
   const debug = (0, _debug.default)('@natlibfi/marc-record-merge');
-  const baseFields = base.get(tagPattern); // Check whether there are subfields to drop from source before copying
-
-  const sourceFields = checkDropSubfields(source.get(tagPattern));
-  return copyFields();
-
-  function copyFields() {
-    const sourceTags = sourceFields.map(field => field.tag);
-    sourceTags.forEach(tag => debug(`Comparing field ${tag}`)); // If compareTagsOnly = true, only this part is run
-    // The field is copied from source only if it is missing completely from base
-
-    if (baseFields.length === 0) {
-      sourceTags.forEach(tag => debug(`Missing field ${tag} copied from source to base`));
-      sourceFields.forEach(f => base.insertField(f));
-      return base;
-    } // If compareTagsOnly = false (default)
-    // Source and base are also compared for identicalness
+  const debugOptions = (0, _debug.default)('@natlibfi/marc-record-merge:compare-options');
+  const debugCompare = (0, _debug.default)('@natlibfi/marc-record-merge:compare');
+  debugOptions(`Tag Pattern: ${tagPattern}`);
+  debugOptions(`Compare tags only: ${compareTagsOnly}`);
+  debugOptions(`Compare without indicators ${compareWithoutIndicators}`);
+  debugOptions(`Copy if identical: ${subfieldsMustBeIdentical}`);
+  debugOptions(`Exclude subfields: [${excludeSubfields}]`);
+  debugOptions(`Drop subfields [${dropSubfields}]`);
+  debugOptions(`Copy unless contains subfields: ${JSON.stringify(copyUnless)}`);
+  const baseFields = baseRecord.get(tagPattern);
+  const sourceFields = sourceRecord.get(tagPattern);
+  const doNotCopy = doNotCopyIfFieldPresent ? baseRecord.get(doNotCopyIfFieldPresent).length > 0 : false;
+
+  if (doNotCopy) {
+    return baseRecord.toObject();
+  }
+
+  debug(`Base fields: `, baseFields);
+  debug(`Source fields: `, sourceFields);
+  const baseCompareFields = baseFields.map(baseField => createCompareField(baseField));
+  const compareResultFields = compareFields(sourceFields, baseCompareFields);
+  const droppedUnwantedSubfield = checkDropSubfields(compareResultFields);
+  const droppedUnwantedFields = checkCopyUnlessFields(droppedUnwantedSubfield);
+  const swappedSubfields = checkSwapSubfieldCodes(droppedUnwantedFields);
+  const swappedTags = checkSwapTag(swappedSubfields);
+  debug('Fields to be copied');
+  debug(JSON.stringify(swappedTags)); // Add fields to base;
+
+  swappedTags.forEach(field => baseRecord.insertField(field));
+  return baseRecord.toObject(); //return copyFields(baseFields, sourceFields);
+
+  function compareFields(sourceFields, baseCompareFields, uniqFields = []) {
+    const [sourceField, ...rest] = sourceFields;
+
+    if (sourceField === undefined) {
+      return uniqFields;
+    }
+
+    if (baseCompareFields.length === 0) {
+      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);
+    } // Source and base are also compared for identicalness
     // Non-identical fields are copied from source to base as duplicates
 
 
-    if (!compareTagsOnly) {
-      const filterMissing = function (sourceField) {
-        if ('value' in sourceField) {
-          debug(`Checking control field ${sourceField.tag} for identicalness`);
-          return baseFields.some(isIdenticalControlField) === false;
+    const sourceCompareField = createCompareField(sourceField);
+    const unique = checkCompareFields(baseCompareFields, sourceCompareField);
+    debugCompare(`${JSON.stringify(sourceField)} ${unique ? 'is UNIQUE' : 'not UNIQUE'}`);
+
+    if (unique) {
+      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);
+    }
+
+    return compareFields(rest, baseCompareFields, uniqFields);
+
+    function checkCompareFields(baseCompareFields, sourceCompareField) {
+      let unique = true; // eslint-disable-line functional/no-let
+
+      baseCompareFields.forEach(baseCompareField => {
+        debugCompare(`Comparing ${JSON.stringify(sourceCompareField)} to ${JSON.stringify(baseCompareField)}}`);
+
+        if (sourceCompareField.value !== baseCompareField.value) {
+          debugCompare(`Value is different ${sourceCompareField.value} !== ${baseCompareField.value}`);
+          return;
         }
 
-        if ('subfields' in sourceField) {
-          debug(`Checking data field ${sourceField.tag} for identicalness`);
-          return baseFields.some(isIdenticalDataField) === false;
+        if (sourceCompareField.ind1 !== baseCompareField.ind1) {
+          debugCompare(`Ind1 is different ${sourceCompareField.ind1} !== ${baseCompareField.ind1}`);
+          return;
         }
 
-        function normalizeControlField(field) {
-          return field.value.toLowerCase().replace(/\s+/u, '');
+        if (sourceCompareField.ind2 !== baseCompareField.ind2) {
+          debugCompare(`Ind2 is different ${sourceCompareField.ind2} !== ${baseCompareField.ind2}`);
+          return;
         }
 
-        function isIdenticalControlField(baseField) {
-          const normalizedBaseField = normalizeControlField(baseField);
-          const normalizedSourceField = normalizeControlField(sourceField);
-          return normalizedSourceField === normalizedBaseField;
+        if ('subfields' in sourceCompareField) {
+          const allFound = checkSubfields(sourceCompareField.subfields, baseCompareField.subfields);
+          debugCompare(`Subfields are different ${!allFound}`);
+
+          if (!allFound) {
+            return;
+          }
+
+          unique = false;
+          return;
         }
 
-        function isIdenticalDataField(baseField) {
-          // If excluded subfields have been defined for this field, they must be ignored first
-          // (i.e. source and base fields are considered identical if all non-excluded subfields are identical)
-          if (excludeSubfields.length > 0 && sourceField.tag === baseField.tag && sourceField.ind1 === baseField.ind1 && sourceField.ind2 === baseField.ind2) {
-            excludeSubfields.forEach(sub => debug(`Subfield ${sub} excluded from identicalness comparison`)); // Compare only those subfields that are not excluded
+        unique = false;
+        return;
+      });
+      return unique;
+    }
 
-            const baseSubsToCompare = baseField.subfields.filter(subfield => excludeSubfields.indexOf(subfield.code) === -1);
-            return baseSubsToCompare.every(isIdenticalSubfield);
-          } // If there are no excluded subfields (default case)
+    function checkSubfields(sourceSubfields, baseSubfields) {
+      const foundSubs = sourceSubfields.filter(sSub => baseSubfields.some(bSub => sSub.code === bSub.code && sSub.value === bSub.value));
 
+      if (subfieldsMustBeIdentical) {
+        return foundSubs.length === sourceSubfields.length && foundSubs.length === baseSubfields.length;
+      }
 
-          if (sourceField.tag === baseField.tag && sourceField.ind1 === baseField.ind1 && sourceField.ind2 === baseField.ind2 && sourceField.subfields.length === baseField.subfields.length) {
-            return baseField.subfields.every(isIdenticalSubfield);
-          }
+      return foundSubs.length === sourceSubfields.length;
+    }
+  }
 
-          function normalizeSubfield(subfield) {
-            return subfield.value.toLowerCase().replace(/\s+/u, '');
-          }
+  function createCompareField(field) {
+    if (compareTagsOnly) {
+      return {
+        tag: field.tag
+      };
+    }
 
-          function isIdenticalSubfield(baseSub) {
-            const normBaseSub = normalizeSubfield(baseSub);
-            return sourceField.subfields.some(sourceSub => {
-              const normSourceSub = normalizeSubfield(sourceSub);
-              return normSourceSub === normBaseSub;
-            });
-          }
-        }
-      }; // Search for fields missing from base
+    if ('value' in field) {
+      return {
+        tag: field.tag,
+        value: field.value
+      };
+    }
 
+    const [filteredField] = checkDropSubfields([field]);
+    const params = [{
+      name: 'tag',
+      value: field.tag
+    }, {
+      name: 'ind1',
+      value: compareWithoutIndicators ? undefined : field.ind1
+    }, {
+      name: 'ind2',
+      value: compareWithoutIndicators ? undefined : field.ind2
+    }, {
+      name: 'subfields',
+      value: createCompareSubfields(filteredField.subfields)
+    }].map(param => [param.name, param.value]);
+    return Object.fromEntries(params);
 
-      const missingFields = sourceFields.filter(filterMissing);
-      missingFields.forEach(f => base.insertField(f));
+    function createCompareSubfields(subfields) {
+      const nonExcludedSubfields = subfields.filter(sub => !excludeSubfields.some(code => code === sub.code));
+      const normalizedSubfields = nonExcludedSubfields.map(sub => ({
+        code: sub.code,
+        value: normalizeSubfieldValue(sub.value)
+      }));
+      return normalizedSubfields;
 
-      if (missingFields.length > 0) {
-        const missingTags = missingFields.map(field => field.tag);
-        missingTags.forEach(tag => debug(`Field ${tag} copied from source to base`));
-        return base;
+      function normalizeSubfieldValue(value) {
+        return value.toLowerCase().replace(/\s+/ug, '');
       }
+    }
+  }
+
+  function checkSwapTag(fields) {
+    if (swapTag.length > 0) {
+      return fields.map(field => ({ ...field,
+        tag: swapTagsFunc(field.tag)
+      }));
+    }
+
+    return fields;
 
-      if (missingFields.length === 0) {
-        debug(`No missing fields found`);
-        return base;
+    function swapTagsFunc(tag) {
+      const [foundRule] = swapTag.filter(rule => new RegExp(rule.from, 'u').test(tag));
+
+      if (foundRule === undefined) {
+        return tag;
       }
+
+      return foundRule.to;
     }
+  }
+
+  function checkSwapSubfieldCodes(fields) {
+    if (swapSubfieldCode.length > 0) {
+      return fields.map(field => ({ ...field,
+        subfields: swapSubfieldCodesFunc(field.subfields)
+      }));
+    }
+
+    return fields;
+
+    function swapSubfieldCodesFunc(subfields) {
+      return subfields.map(sub => {
+        const [foundRule] = swapSubfieldCode.filter(rule => rule.from === sub.code);
+
+        if (foundRule === undefined) {
+          return sub;
+        }
 
-    debug(`No missing fields found`);
-    return base;
+        return {
+          code: foundRule.to,
+          value: sub.value
+        };
+      });
+    }
   }
 
   function checkDropSubfields(fields) {
     if (dropSubfields.length > 0) {
-      dropSubfields.forEach(sub => debug(`Subfield ${sub} dropped from source field before copying`));
       return fields.map(field => ({ ...field,
-        subfields: field.subfields.filter(subfield => dropSubfields.indexOf(subfield.code) === -1)
-      }));
+        subfields: dropSubfieldsFunc(field.subfields)
+      })).filter(field => field.subfields.length > 0);
+    }
+
+    return fields;
+
+    function dropSubfieldsFunc(subfields) {
+      return subfields.filter(sub => {
+        // eslint-disable-line
+        return !dropSubfields.some(({
+          code,
+          value = false,
+          condition = false
+        }) => {
+          if (code !== sub.code) {
+            return false;
+          }
+
+          if (!condition && value) {
+            return value === sub.value;
+          }
+
+          if (condition === 'unless' && value) {
+            return !new RegExp(value, 'u').test(sub.value);
+          }
+
+          return true;
+        });
+      });
+    }
+  }
+
+  function checkCopyUnlessFields(fields) {
+    if (copyUnless.length > 0) {
+      return fields.filter(({
+        subfields
+      }) => copyUnless.some(filter => !subfields.some(sub => sub.code === filter.code && new RegExp(filter.value, 'u').test(sub.value))));
     }
 
-    debug(`No subfields to drop`);
     return fields;
   }
-};
+}; // function copyFields() { //eslint-disable-line no-unused-vars
+//   const sourceTags = sourceFields.map(field => field.tag);
+//   sourceTags.forEach(tag => debug(`Comparing field ${tag}`));
+//   /*
+//   if (combine.length > 0) {
+//     debug(`*** NOW Copy options: ${tagPattern}, ${compareTagsOnly}, ${compareWithoutIndicators}, ${subfieldsMustBeIdentical}, [${combine}], [${excludeSubfields}], [${dropSubfields}]`);
+//     combine.forEach(row => debug(` ### combine ${row} <- `));
+//     return [];
+//   }
+//   */
+//   // If compareTagsOnly = true, only this part is run
+//   // The field is copied from source only if it is missing completely from base
+//   if (compareTagsOnly && baseFields.length === 0) {
+//     sourceTags.forEach(tag => debug(`Missing field ${tag} copied from source to base`));
+//     sourceFields.forEach(f => base.insertField(f));
+//     return true;
+//   }
+//   // If compareTagsOnly = false (default)
+//   // Source and base are also compared for identicalness
+//   // Non-identical fields are copied from source to base as duplicates
+//   if (!compareTagsOnly) {
+//     const filterMissing = function (sourceField) {
+//       if ('value' in sourceField) {
+//         debug(`Checking control field ${sourceField.tag} for identicalness`);
+//         return baseFields.some(isIdenticalControlField) === false;
+//       }
+//       if ('subfields' in sourceField) {
+//         debug(`Checking data field ${sourceField.tag} for identicalness`);
+//         return baseFields.some(isIdenticalDataField) === false;
+//       }
+//       function normalizeControlField(field) {
+//         return field.value.toLowerCase().replace(/\s+/u, '');
+//       }
+//       function isIdenticalControlField(baseField) {
+//         const normalizedBaseField = normalizeControlField(baseField);
+//         const normalizedSourceField = normalizeControlField(sourceField);
+//         return normalizedSourceField === normalizedBaseField;
+//       }
+//       function isIdenticalDataField(baseField) {
+//         // If excluded subfields have been defined for this field, they must be ignored first
+//         // (i.e. source and base fields are considered identical if all non-excluded subfields are identical)
+//         if (excludeSubfields.length > 0 &&
+//           sourceField.tag === baseField.tag &&
+//           sourceField.ind1 === baseField.ind1 &&
+//           sourceField.ind2 === baseField.ind2) {
+//           excludeSubfields.forEach(sub => debug(`Subfield ${sub} excluded from identicalness comparison`));
+//           // Compare only those subfields that are not excluded
+//           const baseSubsToCompare = baseField.subfields.filter(subfield => excludeSubfields.indexOf(subfield.code) === -1);
+//           return baseSubsToCompare.every(isIdenticalSubfield);
+//         }
+//         // If there are no excluded subfields (default case)
+//         if (sourceField.tag === baseField.tag &&
+//           sourceField.ind1 === baseField.ind1 &&
+//           sourceField.ind2 === baseField.ind2 &&
+//           sourceField.subfields.length === baseField.subfields.length) {
+//           return baseField.subfields.every(isIdenticalSubfield);
+//         }
+//         function normalizeSubfield(subfield) {
+//           return subfield.value.toLowerCase().replace(/\s+/u, '');
+//         }
+//         function isIdenticalSubfield(baseSub) {
+//           const normBaseSub = normalizeSubfield(baseSub);
+//           return sourceField.subfields.some(sourceSub => {
+//             const normSourceSub = normalizeSubfield(sourceSub);
+//             return normSourceSub === normBaseSub;
+//           });
+//         }
+//       }
+//     };
+//     // Search for fields missing from base
+//     const missingFields = sourceFields.filter(filterMissing);
+//     missingFields.forEach(f => base.insertField(f));
+//     if (missingFields.length > 0) {
+//       const missingTags = missingFields.map(field => field.tag);
+//       missingTags.forEach(tag => debug(`Field ${tag} copied from source to base`));
+//       return base;
+//     }
+//     if (missingFields.length === 0) {
+//       debug(`No missing fields found`);
+//       return base;
+//     }
+//   }
+//   debug(`No missing fields found`);
+//   return base;
+// }
+
 
 exports.default = _default;
 //# sourceMappingURL=copy.js.map

package/dist/reducers/copy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/reducers/copy.js"],"names":["tagPattern","compareTagsOnly","excludeSubfields","dropSubfields","base","source","debug","baseFields","get","sourceFields","checkDropSubfields","copyFields","sourceTags","map","field","tag","forEach","length","f","insertField","filterMissing","sourceField","some","isIdenticalControlField","isIdenticalDataField","normalizeControlField","value","toLowerCase","replace","baseField","normalizedBaseField","normalizedSourceField","ind1","ind2","sub","baseSubsToCompare","subfields","filter","subfield","indexOf","code","every","isIdenticalSubfield","normalizeSubfield","baseSub","normBaseSub","sourceSub","normSourceSub","missingFields","missingTags","fields"],"mappings":"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","sourcesContent":["/**\n*\n* @licstart  The following is the entire license notice for the JavaScript code in this file.\n*\n* Merge MARC records\n*\n* Copyright (C) 2015-2019 University Of Helsinki (The National Library Of Finland)\n*\n* This file is part of marc-record-merge-js\n\n* marc-record-merge-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* marc-record-merge-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 Lesser 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/**\n * Test 01: If base does not contain the field at all, it is copied from source to base\n * Test 02: Identical control fields are not copied\n * Test 03: Add missing control field to base\n * Test 04: Identical data fields in base and source, not copied\n * Test 05: Different data fields are copied from source to base (multiple fields)\n * Test 06: compareTagsOnly: Field is copied from source only if it is missing in base, a different instance is not copied\n * Test 07: excludeSubfields: Ignore excluded subfields in comparing identicalness\n * Test 08: dropSubfields: Drop subfields from source before copying\n * Test 09: compareTagsOnly for repeatable fields, 2x each 260/264\n * */\nimport createDebugLogger from 'debug';\n\nexport default ({tagPattern, compareTagsOnly = false, excludeSubfields = [], dropSubfields = []}) => (base, source) => {\n  const debug = createDebugLogger('@natlibfi/marc-record-merge');\n  const baseFields = base.get(tagPattern);\n  // Check whether there are subfields to drop from source before copying\n  const sourceFields = checkDropSubfields(source.get(tagPattern));\n  return copyFields();\n\n  function copyFields() {\n    const sourceTags = sourceFields.map(field => field.tag);\n    sourceTags.forEach(tag => debug(`Comparing field ${tag}`));\n\n    // If compareTagsOnly = true, only this part is run\n    // The field is copied from source only if it is missing completely from base\n    if (baseFields.length === 0) {\n      sourceTags.forEach(tag => debug(`Missing field ${tag} copied from source to base`));\n      sourceFields.forEach(f => base.insertField(f));\n      return base;\n    }\n\n    // If compareTagsOnly = false (default)\n    // Source and base are also compared for identicalness\n    // Non-identical fields are copied from source to base as duplicates\n    if (!compareTagsOnly) {\n      const filterMissing = function(sourceField) {\n        if ('value' in sourceField) {\n          debug(`Checking control field ${sourceField.tag} for identicalness`);\n          return baseFields.some(isIdenticalControlField) === false;\n        }\n        if ('subfields' in sourceField) {\n          debug(`Checking data field ${sourceField.tag} for identicalness`);\n          return baseFields.some(isIdenticalDataField) === false;\n        }\n\n        function normalizeControlField(field) {\n          return field.value.toLowerCase().replace(/\\s+/u, '');\n        }\n\n        function isIdenticalControlField(baseField) {\n          const normalizedBaseField = normalizeControlField(baseField);\n          const normalizedSourceField = normalizeControlField(sourceField);\n          return normalizedSourceField === normalizedBaseField;\n        }\n        function isIdenticalDataField(baseField) {\n          // If excluded subfields have been defined for this field, they must be ignored first\n          // (i.e. source and base fields are considered identical if all non-excluded subfields are identical)\n          if (excludeSubfields.length > 0 &&\n            sourceField.tag === baseField.tag &&\n            sourceField.ind1 === baseField.ind1 &&\n            sourceField.ind2 === baseField.ind2) {\n            excludeSubfields.forEach(sub => debug(`Subfield ${sub} excluded from identicalness comparison`));\n            // Compare only those subfields that are not excluded\n            const baseSubsToCompare = baseField.subfields.filter(subfield => excludeSubfields.indexOf(subfield.code) === -1);\n            return baseSubsToCompare.every(isIdenticalSubfield);\n          }\n          // If there are no excluded subfields (default case)\n          if (sourceField.tag === baseField.tag &&\n              sourceField.ind1 === baseField.ind1 &&\n              sourceField.ind2 === baseField.ind2 &&\n              sourceField.subfields.length === baseField.subfields.length) {\n            return baseField.subfields.every(isIdenticalSubfield);\n          }\n          function normalizeSubfield(subfield) {\n            return subfield.value.toLowerCase().replace(/\\s+/u, '');\n          }\n          function isIdenticalSubfield(baseSub) {\n            const normBaseSub = normalizeSubfield(baseSub);\n            return sourceField.subfields.some(sourceSub => {\n              const normSourceSub = normalizeSubfield(sourceSub);\n              return normSourceSub === normBaseSub;\n            });\n          }\n        }\n      };\n      // Search for fields missing from base\n      const missingFields = sourceFields.filter(filterMissing);\n      missingFields.forEach(f => base.insertField(f));\n      if (missingFields.length > 0) {\n        const missingTags = missingFields.map(field => field.tag);\n        missingTags.forEach(tag => debug(`Field ${tag} copied from source to base`));\n        return base;\n      }\n      if (missingFields.length === 0) {\n        debug(`No missing fields found`);\n        return base;\n      }\n    }\n    debug(`No missing fields found`);\n    return base;\n  }\n\n  function checkDropSubfields(fields) {\n    if (dropSubfields.length > 0) {\n      dropSubfields.forEach(sub => debug(`Subfield ${sub} dropped from source field before copying`));\n      return fields.map((field) => ({...field, subfields: field.subfields.filter((subfield) => dropSubfields.indexOf(subfield.code) === -1)}));\n    }\n    debug(`No subfields to drop`);\n    return fields;\n  }\n};\n"],"file":"copy.js"}
+{"version":3,"file":"copy.js","names":["tagPattern","compareTagsOnly","compareWithoutIndicators","subfieldsMustBeIdentical","excludeSubfields","dropSubfields","copyUnless","baseValidators","subfieldValues","sourceValidators","swapTag","swapSubfieldCode","doNotCopyIfFieldPresent","base","source","baseRecord","MarcRecord","sourceRecord","debug","createDebugLogger","debugOptions","debugCompare","JSON","stringify","baseFields","get","sourceFields","doNotCopy","length","toObject","baseCompareFields","map","baseField","createCompareField","compareResultFields","compareFields","droppedUnwantedSubfield","checkDropSubfields","droppedUnwantedFields","checkCopyUnlessFields","swappedSubfields","checkSwapSubfieldCodes","swappedTags","checkSwapTag","forEach","field","insertField","uniqFields","sourceField","rest","undefined","sourceCompareField","unique","checkCompareFields","baseCompareField","value","ind1","ind2","allFound","checkSubfields","subfields","sourceSubfields","baseSubfields","foundSubs","filter","sSub","some","bSub","code","tag","filteredField","params","name","createCompareSubfields","param","Object","fromEntries","nonExcludedSubfields","sub","normalizedSubfields","normalizeSubfieldValue","toLowerCase","replace","fields","swapTagsFunc","foundRule","rule","RegExp","from","test","to","swapSubfieldCodesFunc","dropSubfieldsFunc","condition"],"sources":["../../src/reducers/copy.js"],"sourcesContent":["/* eslint-disable max-statements */\n/* eslint-disable no-unused-vars */\n\nimport {MarcRecord} from '@natlibfi/marc-record';\nimport createDebugLogger from 'debug';\n\nexport default ({\n  tagPattern,\n  compareTagsOnly = false,\n  compareWithoutIndicators = false,\n  subfieldsMustBeIdentical = true,\n  excludeSubfields = [],\n  dropSubfields = [],\n  copyUnless = [],\n  baseValidators = {subfieldValues: false},\n  sourceValidators = {subfieldValues: false},\n  swapTag = [],\n  swapSubfieldCode = [],\n  doNotCopyIfFieldPresent = false\n}) => (base, source) => {\n  const baseRecord = new MarcRecord(base, baseValidators);\n  const sourceRecord = new MarcRecord(source, sourceValidators);\n\n  const debug = createDebugLogger('@natlibfi/marc-record-merge');\n  const debugOptions = createDebugLogger('@natlibfi/marc-record-merge:compare-options');\n  const debugCompare = createDebugLogger('@natlibfi/marc-record-merge:compare');\n  debugOptions(`Tag Pattern: ${tagPattern}`);\n  debugOptions(`Compare tags only: ${compareTagsOnly}`);\n  debugOptions(`Compare without indicators ${compareWithoutIndicators}`);\n  debugOptions(`Copy if identical: ${subfieldsMustBeIdentical}`);\n  debugOptions(`Exclude subfields: [${excludeSubfields}]`);\n  debugOptions(`Drop subfields [${dropSubfields}]`);\n  debugOptions(`Copy unless contains subfields: ${JSON.stringify(copyUnless)}`);\n\n  const baseFields = baseRecord.get(tagPattern);\n  const sourceFields = sourceRecord.get(tagPattern);\n  const doNotCopy = doNotCopyIfFieldPresent ? baseRecord.get(doNotCopyIfFieldPresent).length > 0 : false;\n\n  if (doNotCopy) {\n    return baseRecord.toObject();\n  }\n\n  debug(`Base fields: `, baseFields);\n  debug(`Source fields: `, sourceFields);\n\n  const baseCompareFields = baseFields.map(baseField => createCompareField(baseField));\n  const compareResultFields = compareFields(sourceFields, baseCompareFields);\n  const droppedUnwantedSubfield = checkDropSubfields(compareResultFields);\n  const droppedUnwantedFields = checkCopyUnlessFields(droppedUnwantedSubfield);\n  const swappedSubfields = checkSwapSubfieldCodes(droppedUnwantedFields);\n  const swappedTags = checkSwapTag(swappedSubfields);\n  debug('Fields to be copied');\n  debug(JSON.stringify(swappedTags));\n\n  // Add fields to base;\n  swappedTags.forEach(field => baseRecord.insertField(field));\n  return baseRecord.toObject();\n  //return copyFields(baseFields, sourceFields);\n\n  function compareFields(sourceFields, baseCompareFields, uniqFields = []) {\n    const [sourceField, ...rest] = sourceFields;\n    if (sourceField === undefined) {\n      return uniqFields;\n    }\n\n    if (baseCompareFields.length === 0) {\n      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);\n    }\n\n    // Source and base are also compared for identicalness\n    // Non-identical fields are copied from source to base as duplicates\n    const sourceCompareField = createCompareField(sourceField);\n    const unique = checkCompareFields(baseCompareFields, sourceCompareField);\n\n    debugCompare(`${JSON.stringify(sourceField)} ${unique ? 'is UNIQUE' : 'not UNIQUE'}`);\n\n    if (unique) {\n      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);\n    }\n\n    return compareFields(rest, baseCompareFields, uniqFields);\n\n    function checkCompareFields(baseCompareFields, sourceCompareField) {\n      let unique = true; // eslint-disable-line functional/no-let\n\n      baseCompareFields.forEach(baseCompareField => {\n        debugCompare(`Comparing ${JSON.stringify(sourceCompareField)} to ${JSON.stringify(baseCompareField)}}`);\n\n        if (sourceCompareField.value !== baseCompareField.value) {\n          debugCompare(`Value is different ${sourceCompareField.value} !== ${baseCompareField.value}`);\n          return;\n        }\n\n        if (sourceCompareField.ind1 !== baseCompareField.ind1) {\n          debugCompare(`Ind1 is different ${sourceCompareField.ind1} !== ${baseCompareField.ind1}`);\n          return;\n        }\n\n        if (sourceCompareField.ind2 !== baseCompareField.ind2) {\n          debugCompare(`Ind2 is different ${sourceCompareField.ind2} !== ${baseCompareField.ind2}`);\n          return;\n        }\n\n        if ('subfields' in sourceCompareField) {\n          const allFound = checkSubfields(sourceCompareField.subfields, baseCompareField.subfields);\n          debugCompare(`Subfields are different ${!allFound}`);\n          if (!allFound) {\n            return;\n          }\n\n          unique = false;\n          return;\n        }\n\n        unique = false;\n        return;\n      });\n\n      return unique;\n    }\n\n    function checkSubfields(sourceSubfields, baseSubfields) {\n      const foundSubs = sourceSubfields.filter(sSub => baseSubfields.some(bSub => sSub.code === bSub.code && sSub.value === bSub.value));\n\n      if (subfieldsMustBeIdentical) {\n        return foundSubs.length === sourceSubfields.length && foundSubs.length === baseSubfields.length;\n      }\n\n      return foundSubs.length === sourceSubfields.length;\n    }\n  }\n\n  function createCompareField(field) {\n    if (compareTagsOnly) {\n      return {tag: field.tag};\n    }\n\n    if ('value' in field) {\n      return {tag: field.tag, value: field.value};\n    }\n\n    const [filteredField] = checkDropSubfields([field]);\n\n    const params = [\n      {name: 'tag', value: field.tag},\n      {name: 'ind1', value: compareWithoutIndicators ? undefined : field.ind1},\n      {name: 'ind2', value: compareWithoutIndicators ? undefined : field.ind2},\n      {name: 'subfields', value: createCompareSubfields(filteredField.subfields)}\n    ].map(param => [param.name, param.value]);\n\n    return Object.fromEntries(params);\n\n    function createCompareSubfields(subfields) {\n      const nonExcludedSubfields = subfields.filter(sub => !excludeSubfields.some(code => code === sub.code));\n      const normalizedSubfields = nonExcludedSubfields.map(sub => ({code: sub.code, value: normalizeSubfieldValue(sub.value)}));\n\n      return normalizedSubfields;\n\n      function normalizeSubfieldValue(value) {\n        return value.toLowerCase().replace(/\\s+/ug, '');\n      }\n    }\n  }\n\n  function checkSwapTag(fields) {\n    if (swapTag.length > 0) {\n      return fields.map(field => ({...field, tag: swapTagsFunc(field.tag)}));\n    }\n\n    return fields;\n\n    function swapTagsFunc(tag) {\n      const [foundRule] = swapTag.filter(rule => new RegExp(rule.from, 'u').test(tag));\n\n      if (foundRule === undefined) {\n        return tag;\n      }\n\n      return foundRule.to;\n    }\n  }\n\n  function checkSwapSubfieldCodes(fields) {\n    if (swapSubfieldCode.length > 0) {\n      return fields.map(field => ({...field, subfields: swapSubfieldCodesFunc(field.subfields)}));\n    }\n\n    return fields;\n\n    function swapSubfieldCodesFunc(subfields) {\n      return subfields.map(sub => {\n        const [foundRule] = swapSubfieldCode.filter(rule => rule.from === sub.code);\n\n        if (foundRule === undefined) {\n          return sub;\n        }\n\n        return {code: foundRule.to, value: sub.value};\n      });\n    }\n  }\n\n  function checkDropSubfields(fields) {\n    if (dropSubfields.length > 0) {\n      return fields.map(field => ({...field, subfields: dropSubfieldsFunc(field.subfields)}))\n        .filter(field => field.subfields.length > 0);\n    }\n\n    return fields;\n\n    function dropSubfieldsFunc(subfields) {\n      return subfields.filter(sub => { // eslint-disable-line\n        return !dropSubfields.some(({code, value = false, condition = false}) => {\n          if (code !== sub.code) {\n            return false;\n          }\n\n          if (!condition && value) {\n            return value === sub.value;\n          }\n\n          if (condition === 'unless' && value) {\n            return !new RegExp(value, 'u').test(sub.value);\n          }\n\n          return true;\n        });\n      });\n    }\n  }\n\n  function checkCopyUnlessFields(fields) {\n    if (copyUnless.length > 0) {\n      return fields.filter(({subfields}) => copyUnless.some(filter => !subfields.some(sub => sub.code === filter.code && new RegExp(filter.value, 'u').test(sub.value))));\n    }\n\n    return fields;\n  }\n};\n\n// function copyFields() { //eslint-disable-line no-unused-vars\n//   const sourceTags = sourceFields.map(field => field.tag);\n//   sourceTags.forEach(tag => debug(`Comparing field ${tag}`));\n\n//   /*\n//   if (combine.length > 0) {\n//     debug(`*** NOW Copy options: ${tagPattern}, ${compareTagsOnly}, ${compareWithoutIndicators}, ${subfieldsMustBeIdentical}, [${combine}], [${excludeSubfields}], [${dropSubfields}]`);\n//     combine.forEach(row => debug(` ### combine ${row} <- `));\n//     return [];\n//   }\n//   */\n\n//   // If compareTagsOnly = true, only this part is run\n//   // The field is copied from source only if it is missing completely from base\n//   if (compareTagsOnly && baseFields.length === 0) {\n//     sourceTags.forEach(tag => debug(`Missing field ${tag} copied from source to base`));\n//     sourceFields.forEach(f => base.insertField(f));\n//     return true;\n//   }\n\n//   // If compareTagsOnly = false (default)\n//   // Source and base are also compared for identicalness\n//   // Non-identical fields are copied from source to base as duplicates\n//   if (!compareTagsOnly) {\n//     const filterMissing = function (sourceField) {\n//       if ('value' in sourceField) {\n//         debug(`Checking control field ${sourceField.tag} for identicalness`);\n//         return baseFields.some(isIdenticalControlField) === false;\n//       }\n//       if ('subfields' in sourceField) {\n//         debug(`Checking data field ${sourceField.tag} for identicalness`);\n//         return baseFields.some(isIdenticalDataField) === false;\n//       }\n\n//       function normalizeControlField(field) {\n//         return field.value.toLowerCase().replace(/\\s+/u, '');\n//       }\n\n//       function isIdenticalControlField(baseField) {\n//         const normalizedBaseField = normalizeControlField(baseField);\n//         const normalizedSourceField = normalizeControlField(sourceField);\n//         return normalizedSourceField === normalizedBaseField;\n//       }\n\n//       function isIdenticalDataField(baseField) {\n//         // If excluded subfields have been defined for this field, they must be ignored first\n//         // (i.e. source and base fields are considered identical if all non-excluded subfields are identical)\n//         if (excludeSubfields.length > 0 &&\n//           sourceField.tag === baseField.tag &&\n//           sourceField.ind1 === baseField.ind1 &&\n//           sourceField.ind2 === baseField.ind2) {\n//           excludeSubfields.forEach(sub => debug(`Subfield ${sub} excluded from identicalness comparison`));\n//           // Compare only those subfields that are not excluded\n//           const baseSubsToCompare = baseField.subfields.filter(subfield => excludeSubfields.indexOf(subfield.code) === -1);\n//           return baseSubsToCompare.every(isIdenticalSubfield);\n//         }\n//         // If there are no excluded subfields (default case)\n//         if (sourceField.tag === baseField.tag &&\n//           sourceField.ind1 === baseField.ind1 &&\n//           sourceField.ind2 === baseField.ind2 &&\n//           sourceField.subfields.length === baseField.subfields.length) {\n//           return baseField.subfields.every(isIdenticalSubfield);\n//         }\n//         function normalizeSubfield(subfield) {\n//           return subfield.value.toLowerCase().replace(/\\s+/u, '');\n//         }\n//         function isIdenticalSubfield(baseSub) {\n//           const normBaseSub = normalizeSubfield(baseSub);\n//           return sourceField.subfields.some(sourceSub => {\n//             const normSourceSub = normalizeSubfield(sourceSub);\n//             return normSourceSub === normBaseSub;\n//           });\n//         }\n//       }\n//     };\n//     // Search for fields missing from base\n//     const missingFields = sourceFields.filter(filterMissing);\n//     missingFields.forEach(f => base.insertField(f));\n//     if (missingFields.length > 0) {\n//       const missingTags = missingFields.map(field => field.tag);\n//       missingTags.forEach(tag => debug(`Field ${tag} copied from source to base`));\n//       return base;\n//     }\n//     if (missingFields.length === 0) {\n//       debug(`No missing fields found`);\n//       return base;\n//     }\n//   }\n//   debug(`No missing fields found`);\n//   return base;\n// }\n"],"mappings":"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Ad,IAA0BtC,KAA9B,EAAqC;YACnC,OAAO,CAAC,IAAIgC,MAAJ,CAAWhC,KAAX,EAAkB,GAAlB,EAAuBkC,IAAvB,CAA4BX,GAAG,CAACvB,KAAhC,CAAR;UACD;;UAED,OAAO,IAAP;QACD,CAdO,CAAR;MAeD,CAhBM,CAAP;IAiBD;EACF;;EAED,SAAShB,qBAAT,CAA+B4C,MAA/B,EAAuC;IACrC,IAAI7E,UAAU,CAACsB,MAAX,GAAoB,CAAxB,EAA2B;MACzB,OAAOuD,MAAM,CAACnB,MAAP,CAAc,CAAC;QAACJ;MAAD,CAAD,KAAiBtD,UAAU,CAAC4D,IAAX,CAAgBF,MAAM,IAAI,CAACJ,SAAS,CAACM,IAAV,CAAeY,GAAG,IAAIA,GAAG,CAACV,IAAJ,KAAaJ,MAAM,CAACI,IAApB,IAA4B,IAAImB,MAAJ,CAAWvB,MAAM,CAACT,KAAlB,EAAyB,GAAzB,EAA8BkC,IAA9B,CAAmCX,GAAG,CAACvB,KAAvC,CAAlD,CAA3B,CAA/B,CAAP;IACD;;IAED,OAAO4B,MAAP;EACD;AACF,C,EAED;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"}