@natlibfi/marc-record-validators-melinda 3.2.0 → 3.3.14-alpha.3

package/dist/index.js

@@ -1,28 +1,203 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* MARC record validators used in Melinda
-*
-* Copyright (C) 2014-2018 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of marc-record-validators-melinda
-*
-* marc-record-validators-melinda program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Affero 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-validators-melinda 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 Affero 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.
-*
-*//* eslint-disable no-unused-vars */'use strict';Object.defineProperty(exports,'__esModule',{value:true});exports.UnicodeDecomposition=exports.SortTags=exports.ResolvableExtReferences=exports.ItemLanguage=exports.IsbnIssn=exports.IdenticalFields=exports.FixedFields=exports.FieldStructure=exports.FieldsPresent=exports.FieldExclusion=exports.EndingPunctuation=exports.EmptyFields=exports.DuplicatesInd1=exports.DoubleCommas=undefined;var _doubleCommas=require('./double-commas');var _doubleCommas2=_interopRequireDefault(_doubleCommas);var _duplicatesInd=require('./duplicates-ind1');var _duplicatesInd2=_interopRequireDefault(_duplicatesInd);var _emptyFields=require('./empty-fields');var _emptyFields2=_interopRequireDefault(_emptyFields);var _endingPunctuation=require('./ending-punctuation');var _endingPunctuation2=_interopRequireDefault(_endingPunctuation);var _fieldsPresent=require('./fields-present');var _fieldsPresent2=_interopRequireDefault(_fieldsPresent);var _fieldStructure=require('./field-structure');var _fieldStructure2=_interopRequireDefault(_fieldStructure);var _fixedFields=require('./fixed-fields');var _fixedFields2=_interopRequireDefault(_fixedFields);var _fieldExclusion=require('./field-exclusion');var _fieldExclusion2=_interopRequireDefault(_fieldExclusion);var _identicalFields=require('./identical-fields');var _identicalFields2=_interopRequireDefault(_identicalFields);var _isbnIssn=require('./isbn-issn');var _isbnIssn2=_interopRequireDefault(_isbnIssn);var _itemLanguage=require('./item-language');var _itemLanguage2=_interopRequireDefault(_itemLanguage);var _resolvableExtReferencesMelinda=require('./resolvable-ext-references-melinda');var _resolvableExtReferencesMelinda2=_interopRequireDefault(_resolvableExtReferencesMelinda);var _sortTags=require('./sort-tags');var _sortTags2=_interopRequireDefault(_sortTags);var _subfieldExclusion=require('./subfield-exclusion');var _subfieldExclusion2=_interopRequireDefault(_subfieldExclusion);var _unicodeDecomposition=require('./unicode-decomposition');var _unicodeDecomposition2=_interopRequireDefault(_unicodeDecomposition);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}exports.DoubleCommas=_doubleCommas2.default;exports.DuplicatesInd1=_duplicatesInd2.default;exports.EmptyFields=_emptyFields2.default;exports.EndingPunctuation=_endingPunctuation2.default;exports.FieldExclusion=_fieldExclusion2.default;exports.FieldsPresent=_fieldsPresent2.default;exports.FieldStructure=_fieldStructure2.default;exports.FixedFields=_fixedFields2.default;exports.IdenticalFields=_identicalFields2.default;exports.IsbnIssn=_isbnIssn2.default;exports.ItemLanguage=_itemLanguage2.default;exports.ResolvableExtReferences=_resolvableExtReferencesMelinda2.default;exports.SortTags=_sortTags2.default;exports.UnicodeDecomposition=_unicodeDecomposition2.default;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AccessRights", {
+  enumerable: true,
+  get: function () {
+    return _accessRights.default;
+  }
+});
+Object.defineProperty(exports, "DoubleCommas", {
+  enumerable: true,
+  get: function () {
+    return _doubleCommas.default;
+  }
+});
+Object.defineProperty(exports, "DuplicatesInd1", {
+  enumerable: true,
+  get: function () {
+    return _duplicatesInd.default;
+  }
+});
+Object.defineProperty(exports, "EmptyFields", {
+  enumerable: true,
+  get: function () {
+    return _emptyFields.default;
+  }
+});
+Object.defineProperty(exports, "EndingPunctuation", {
+  enumerable: true,
+  get: function () {
+    return _endingPunctuation.default;
+  }
+});
+Object.defineProperty(exports, "EndingWhitespace", {
+  enumerable: true,
+  get: function () {
+    return _endingWhitespace.default;
+  }
+});
+Object.defineProperty(exports, "Field521Fix", {
+  enumerable: true,
+  get: function () {
+    return _field521Fix.default;
+  }
+});
+Object.defineProperty(exports, "FieldExclusion", {
+  enumerable: true,
+  get: function () {
+    return _fieldExclusion.default;
+  }
+});
+Object.defineProperty(exports, "FieldStructure", {
+  enumerable: true,
+  get: function () {
+    return _fieldStructure.default;
+  }
+});
+Object.defineProperty(exports, "FieldsPresent", {
+  enumerable: true,
+  get: function () {
+    return _fieldsPresent.default;
+  }
+});
+Object.defineProperty(exports, "FixedFields", {
+  enumerable: true,
+  get: function () {
+    return _fixedFields.default;
+  }
+});
+Object.defineProperty(exports, "IdenticalFields", {
+  enumerable: true,
+  get: function () {
+    return _identicalFields.default;
+  }
+});
+Object.defineProperty(exports, "IsbnIssn", {
+  enumerable: true,
+  get: function () {
+    return _isbnIssn.default;
+  }
+});
+Object.defineProperty(exports, "ItemLanguage", {
+  enumerable: true,
+  get: function () {
+    return _itemLanguage.default;
+  }
+});
+Object.defineProperty(exports, "NonBreakingSpace", {
+  enumerable: true,
+  get: function () {
+    return _nonBreakingSpace.default;
+  }
+});
+Object.defineProperty(exports, "NormalizeUTF8Diacritics", {
+  enumerable: true,
+  get: function () {
+    return _normalizeUtf8Diacritics.default;
+  }
+});
+Object.defineProperty(exports, "Punctuation", {
+  enumerable: true,
+  get: function () {
+    return _punctuation.default;
+  }
+});
+Object.defineProperty(exports, "ReindexSubfield6OccurenceNumbers", {
+  enumerable: true,
+  get: function () {
+    return _reindexSubfield6OccurenceNumbers.default;
+  }
+});
+Object.defineProperty(exports, "ResolvableExtReferences", {
+  enumerable: true,
+  get: function () {
+    return _resolvableExtReferencesMelinda.default;
+  }
+});
+Object.defineProperty(exports, "ResolveOrphanedSubfield6s", {
+  enumerable: true,
+  get: function () {
+    return _resolveOrphanedSubfield6s.default;
+  }
+});
+Object.defineProperty(exports, "SanitizeVocabularySourceCodes", {
+  enumerable: true,
+  get: function () {
+    return _sanitizeVocabularySourceCodes.default;
+  }
+});
+Object.defineProperty(exports, "SortSubfields", {
+  enumerable: true,
+  get: function () {
+    return _sortSubfields.default;
+  }
+});
+Object.defineProperty(exports, "SortTags", {
+  enumerable: true,
+  get: function () {
+    return _sortTags.default;
+  }
+});
+Object.defineProperty(exports, "SubfieldExclusion", {
+  enumerable: true,
+  get: function () {
+    return _subfieldExclusion.default;
+  }
+});
+Object.defineProperty(exports, "TypeOfDateF008", {
+  enumerable: true,
+  get: function () {
+    return _typeOfDate.default;
+  }
+});
+Object.defineProperty(exports, "UnicodeDecomposition", {
+  enumerable: true,
+  get: function () {
+    return _unicodeDecomposition.default;
+  }
+});
+Object.defineProperty(exports, "UpdateField540", {
+  enumerable: true,
+  get: function () {
+    return _updateField.default;
+  }
+});
+Object.defineProperty(exports, "Urn", {
+  enumerable: true,
+  get: function () {
+    return _urn.default;
+  }
+});
+var _accessRights = _interopRequireDefault(require("./access-rights"));
+var _doubleCommas = _interopRequireDefault(require("./double-commas"));
+var _duplicatesInd = _interopRequireDefault(require("./duplicates-ind1"));
+var _emptyFields = _interopRequireDefault(require("./empty-fields"));
+var _endingPunctuation = _interopRequireDefault(require("./ending-punctuation"));
+var _endingWhitespace = _interopRequireDefault(require("./ending-whitespace"));
+var _field521Fix = _interopRequireDefault(require("./field-521-fix"));
+var _fieldsPresent = _interopRequireDefault(require("./fields-present"));
+var _fieldStructure = _interopRequireDefault(require("./field-structure"));
+var _fixedFields = _interopRequireDefault(require("./fixed-fields"));
+var _fieldExclusion = _interopRequireDefault(require("./field-exclusion"));
+var _identicalFields = _interopRequireDefault(require("./identical-fields"));
+var _isbnIssn = _interopRequireDefault(require("./isbn-issn"));
+var _itemLanguage = _interopRequireDefault(require("./item-language"));
+var _nonBreakingSpace = _interopRequireDefault(require("./non-breaking-space"));
+var _normalizeUtf8Diacritics = _interopRequireDefault(require("./normalize-utf8-diacritics"));
+var _punctuation = _interopRequireDefault(require("./punctuation/"));
+var _resolveOrphanedSubfield6s = _interopRequireDefault(require("./resolveOrphanedSubfield6s"));
+var _reindexSubfield6OccurenceNumbers = _interopRequireDefault(require("./reindexSubfield6OccurenceNumbers"));
+var _resolvableExtReferencesMelinda = _interopRequireDefault(require("./resolvable-ext-references-melinda"));
+var _sanitizeVocabularySourceCodes = _interopRequireDefault(require("./sanitize-vocabulary-source-codes"));
+var _updateField = _interopRequireDefault(require("./update-field-540"));
+var _sortSubfields = _interopRequireDefault(require("./sortSubfields"));
+var _sortTags = _interopRequireDefault(require("./sort-tags"));
+var _subfieldExclusion = _interopRequireDefault(require("./subfield-exclusion"));
+var _typeOfDate = _interopRequireDefault(require("./typeOfDate-008"));
+var _unicodeDecomposition = _interopRequireDefault(require("./unicode-decomposition"));
+var _urn = _interopRequireDefault(require("./urn"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.js"],"names":["DoubleCommas","DuplicatesInd1","EmptyFields","EndingPunctuation","FieldExclusion","FieldsPresent","FieldStructure","FixedFields","IdenticalFields","IsbnIssn","ItemLanguage","ResolvableExtReferences","SortTags","UnicodeDecomposition"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BA,mCAEA,a,iYAEA,6C,yDACA,gD,2DACA,2C,uDACA,uD,mEACA,+C,2DACA,iD,6DACA,2C,uDACA,iD,6DACA,mD,+DACA,qC,iDACA,6C,yDACA,mF,6FACA,qC,iDACA,uD,mEACA,6D,mKAGCA,Y,CAAAA,sB,SACAC,c,CAAAA,uB,SACAC,W,CAAAA,qB,SACAC,iB,CAAAA,2B,SACAC,c,CAAAA,wB,SACAC,a,CAAAA,uB,SACAC,c,CAAAA,wB,SACAC,W,CAAAA,qB,SACAC,e,CAAAA,yB,SACAC,Q,CAAAA,kB,SACAC,Y,CAAAA,sB,SACAC,uB,CAAAA,wC,SACAC,Q,CAAAA,kB,SACAC,oB,CAAAA,8B","file":"index.js","sourcesContent":["/**\n*\n* @licstart  The following is the entire license notice for the JavaScript code in this file.\n*\n* MARC record validators used in Melinda\n*\n* Copyright (C) 2014-2018 University Of Helsinki (The National Library Of Finland)\n*\n* This file is part of marc-record-validators-melinda\n*\n* marc-record-validators-melinda program is free software: you can redistribute it and/or modify\n* it under the terms of the GNU Affero 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-validators-melinda 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 Affero 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/* eslint-disable no-unused-vars */\n\n'use strict';\n\nimport DoubleCommas from './double-commas';\nimport DuplicatesInd1 from './duplicates-ind1';\nimport EmptyFields from './empty-fields';\nimport EndingPunctuation from './ending-punctuation';\nimport FieldsPresent from './fields-present';\nimport FieldStructure from './field-structure';\nimport FixedFields from './fixed-fields';\nimport FieldExclusion from './field-exclusion';\nimport IdenticalFields from './identical-fields';\nimport IsbnIssn from './isbn-issn';\nimport ItemLanguage from './item-language';\nimport ResolvableExtReferences from './resolvable-ext-references-melinda';\nimport SortTags from './sort-tags';\nimport SubfieldExclusion from './subfield-exclusion';\nimport UnicodeDecomposition from './unicode-decomposition';\n\nexport {\n\tDoubleCommas,\n\tDuplicatesInd1,\n\tEmptyFields,\n\tEndingPunctuation,\n\tFieldExclusion,\n\tFieldsPresent,\n\tFieldStructure,\n\tFixedFields,\n\tIdenticalFields,\n\tIsbnIssn,\n\tItemLanguage,\n\tResolvableExtReferences,\n\tSortTags,\n\tUnicodeDecomposition\n};\n"]}
+{"version":3,"file":"index.js","names":["_accessRights","_interopRequireDefault","require","_doubleCommas","_duplicatesInd","_emptyFields","_endingPunctuation","_endingWhitespace","_field521Fix","_fieldsPresent","_fieldStructure","_fixedFields","_fieldExclusion","_identicalFields","_isbnIssn","_itemLanguage","_nonBreakingSpace","_normalizeUtf8Diacritics","_punctuation","_resolveOrphanedSubfield6s","_reindexSubfield6OccurenceNumbers","_resolvableExtReferencesMelinda","_sanitizeVocabularySourceCodes","_updateField","_sortSubfields","_sortTags","_subfieldExclusion","_typeOfDate","_unicodeDecomposition","_urn","obj","__esModule","default"],"sources":["../src/index.js"],"sourcesContent":["import AccessRights from './access-rights';\nimport DoubleCommas from './double-commas';\nimport DuplicatesInd1 from './duplicates-ind1';\nimport EmptyFields from './empty-fields';\nimport EndingPunctuation from './ending-punctuation';\nimport EndingWhitespace from './ending-whitespace';\nimport Field521Fix from './field-521-fix';\nimport FieldsPresent from './fields-present';\nimport FieldStructure from './field-structure';\nimport FixedFields from './fixed-fields';\nimport FieldExclusion from './field-exclusion';\nimport IdenticalFields from './identical-fields';\nimport IsbnIssn from './isbn-issn';\nimport ItemLanguage from './item-language';\nimport NonBreakingSpace from './non-breaking-space';\nimport NormalizeUTF8Diacritics from './normalize-utf8-diacritics';\nimport Punctuation from './punctuation/';\nimport ResolveOrphanedSubfield6s from './resolveOrphanedSubfield6s'; // Do this before reindexing!\nimport ReindexSubfield6OccurenceNumbers from './reindexSubfield6OccurenceNumbers';\nimport ResolvableExtReferences from './resolvable-ext-references-melinda';\nimport SanitizeVocabularySourceCodes from './sanitize-vocabulary-source-codes';\nimport UpdateField540 from './update-field-540';\nimport SortSubfields from './sortSubfields';\nimport SortTags from './sort-tags';\nimport SubfieldExclusion from './subfield-exclusion';\nimport TypeOfDateF008 from './typeOfDate-008';\nimport UnicodeDecomposition from './unicode-decomposition';\nimport Urn from './urn';\n\nexport {\n  AccessRights,\n  DoubleCommas,\n  DuplicatesInd1,\n  EmptyFields,\n  EndingPunctuation,\n  EndingWhitespace,\n  Field521Fix,\n  FieldExclusion,\n  FieldsPresent,\n  FieldStructure,\n  FixedFields,\n  IdenticalFields,\n  IsbnIssn,\n  ItemLanguage,\n  NonBreakingSpace,\n  NormalizeUTF8Diacritics,\n  Punctuation,\n  ResolveOrphanedSubfield6s,\n  ReindexSubfield6OccurenceNumbers,\n  ResolvableExtReferences,\n  SanitizeVocabularySourceCodes,\n  SortSubfields,\n  SortTags,\n  SubfieldExclusion,\n  TypeOfDateF008,\n  UnicodeDecomposition,\n  UpdateField540,\n  Urn\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,aAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,aAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,cAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,YAAA,GAAAJ,sBAAA,CAAAC,OAAA;AACA,IAAAI,kBAAA,GAAAL,sBAAA,CAAAC,OAAA;AACA,IAAAK,iBAAA,GAAAN,sBAAA,CAAAC,OAAA;AACA,IAAAM,YAAA,GAAAP,sBAAA,CAAAC,OAAA;AACA,IAAAO,cAAA,GAAAR,sBAAA,CAAAC,OAAA;AACA,IAAAQ,eAAA,GAAAT,sBAAA,CAAAC,OAAA;AACA,IAAAS,YAAA,GAAAV,sBAAA,CAAAC,OAAA;AACA,IAAAU,eAAA,GAAAX,sBAAA,CAAAC,OAAA;AACA,IAAAW,gBAAA,GAAAZ,sBAAA,CAAAC,OAAA;AACA,IAAAY,SAAA,GAAAb,sBAAA,CAAAC,OAAA;AACA,IAAAa,aAAA,GAAAd,sBAAA,CAAAC,OAAA;AACA,IAAAc,iBAAA,GAAAf,sBAAA,CAAAC,OAAA;AACA,IAAAe,wBAAA,GAAAhB,sBAAA,CAAAC,OAAA;AACA,IAAAgB,YAAA,GAAAjB,sBAAA,CAAAC,OAAA;AACA,IAAAiB,0BAAA,GAAAlB,sBAAA,CAAAC,OAAA;AACA,IAAAkB,iCAAA,GAAAnB,sBAAA,CAAAC,OAAA;AACA,IAAAmB,+BAAA,GAAApB,sBAAA,CAAAC,OAAA;AACA,IAAAoB,8BAAA,GAAArB,sBAAA,CAAAC,OAAA;AACA,IAAAqB,YAAA,GAAAtB,sBAAA,CAAAC,OAAA;AACA,IAAAsB,cAAA,GAAAvB,sBAAA,CAAAC,OAAA;AACA,IAAAuB,SAAA,GAAAxB,sBAAA,CAAAC,OAAA;AACA,IAAAwB,kBAAA,GAAAzB,sBAAA,CAAAC,OAAA;AACA,IAAAyB,WAAA,GAAA1B,sBAAA,CAAAC,OAAA;AACA,IAAA0B,qBAAA,GAAA3B,sBAAA,CAAAC,OAAA;AACA,IAAA2B,IAAA,GAAA5B,sBAAA,CAAAC,OAAA;AAAwB,SAAAD,uBAAA6B,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA"}

package/dist/indicator-fixes.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.recordNormalizeIndicators = recordNormalizeIndicators;
+var _utils = require("./utils");
+// Relocated from melinda-marc-record-merge-reducers (and renamed)
+//import createDebugLogger from 'debug';
+//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normalizeIdentifiers');
+
+function _default() {
+  return {
+    description: 'Normalizes indicator values',
+    validate,
+    fix
+  };
+  function fix(record) {
+    const res = {
+      message: [],
+      fix: [],
+      valid: true
+    };
+    recordNormalizeIndicators(record);
+    return res;
+  }
+  function validate(record) {
+    const res = {
+      message: []
+    };
+    validateRecord(record, res);
+    res.valid = res.message.length < 1; // eslint-disable-line functional/immutable-data
+    return res;
+  }
+  function validateRecord(record, res) {
+    //nvdebug(record);
+    const clonedFields = JSON.parse(JSON.stringify(record.fields));
+    recordNormalizeIndicators(record);
+    record.fields.forEach((field, index) => compareFields(field, index));
+    function compareFields(field, index) {
+      const origFieldAsString = (0, _utils.fieldToString)(clonedFields[index]);
+      //const clonedFieldAsString = fieldToString(field);
+      if (clonedFields[index].ind1 !== field.ind1) {
+        // eslint-disable-line functional/no-conditional-statements
+        //nvdebug(`FIX IND1: '${clonedFields[index].ind1}' => '${field.ind1}': ${clonedFieldAsString}`);
+        res.message.push(`Expected IND1 for '${origFieldAsString}' is '${field.ind1}'`); // eslint-disable-line functional/immutable-data
+      }
+
+      if (clonedFields[index].ind2 !== field.ind2) {
+        // eslint-disable-line functional/no-conditional-statements
+        //nvdebug(`FIX IND2: '${clonedFields[index].ind2}' => '${field.ind2}': ${clonedFieldAsString}`);
+        res.message.push(`Expected IND2 for '${origFieldAsString}' is '${field.ind2}'`); // eslint-disable-line functional/immutable-data
+      }
+    }
+    // Validator should not change the original record:
+    record.fields = clonedFields; // eslint-disable-line functional/immutable-data
+    return;
+  }
+}
+const ind1NonFilingChars = ['130', '630', '730', '740'];
+const ind2NonFilingChars = ['222', '240', '242', '243', '245', '830'];
+function hasNonFilingIndicator1(field) {
+  return ind1NonFilingChars.includes(field.tag);
+}
+function modifiableIndicatorValue(value) {
+  // If field contains a legit-looking value, don't try to modify it here...
+  return !['9', '8', '7', '6', '5', '4', '3', '2', '1'].includes(value);
+}
+function hasNonFilingIndicator2(field) {
+  return ind2NonFilingChars.includes(field.tag);
+}
+function valueBeginsWithDeterminer(value, cands) {
+  return cands.find(cand => value.substring(0, cand.length) === cand);
+}
+function determineNonFilingIndicatorValue(field, languages = undefined) {
+  const subfieldA = field.subfields.find(sf => sf.code === 'a');
+  if (!subfieldA) {
+    // nvdebug(' Subfield $a miss!');
+    return;
+  }
+  const name = subfieldA.value.toLowerCase();
+  if (languages.includes('eng')) {
+    const match = valueBeginsWithDeterminer(name, ['a ', 'an ', 'the ']);
+    if (match) {
+      return `${match.length}`;
+    }
+  }
+  if (languages.includes('fre')) {
+    const match = valueBeginsWithDeterminer(name, ['l\'', 'le ']);
+    if (match) {
+      return `${match.length}`;
+    }
+  }
+  if (languages.includes('ger')) {
+    const match = valueBeginsWithDeterminer(name, ['das ', 'der ', 'die ']);
+    if (match) {
+      return `${match.length}`;
+    }
+  }
+  if (languages.includes('swe')) {
+    const match = valueBeginsWithDeterminer(name, ['en ', 'ett ']);
+    if (match) {
+      return `${match.length}`;
+    }
+  }
+
+  // Fallback-ish: try to guess even without languages:
+  const match = valueBeginsWithDeterminer(name, ['the ']);
+  if (match) {
+    return `${match.length}`;
+  }
+  return '0';
+}
+function normalizeNonFilingIndicator1(field, languages = []) {
+  if (!hasNonFilingIndicator1(field) || !modifiableIndicatorValue(field.ind1)) {
+    return;
+  }
+  field.ind1 = determineNonFilingIndicatorValue(field, languages); // eslint-disable-line functional/immutable-data
+}
+
+function normalizeNonFilingIndicator2(field, languages = []) {
+  if (!hasNonFilingIndicator2(field) || !modifiableIndicatorValue(field.ind2)) {
+    return;
+  }
+  field.ind2 = determineNonFilingIndicatorValue(field, languages); // eslint-disable-line functional/immutable-data
+}
+
+function normalize245Indicator1(field, record) {
+  if (field.tag !== '245') {
+    return;
+  }
+  const field1XX = record.get('^1..$');
+  field.ind1 = field1XX.length === 0 ? '0' : '1'; // eslint-disable-line functional/immutable-data
+}
+
+function recordNormalize490(record) {
+  const fields490 = record.get('^490$');
+  const fields8XX = record.get('^(?:800|810|811|830)$');
+  if (fields490.length === 0) {
+    return;
+  }
+  if (fields490.length <= fields8XX.length) {
+    // Trace found for each field 490:
+    fields490.forEach(f => {
+      f.ind1 = '1'; // eslint-disable-line functional/immutable-data
+    });
+
+    return;
+  }
+  if (fields8XX.length === 0) {
+    // Fields 490 are always untraced (no traces found)
+    fields490.forEach(f => {
+      f.ind1 = '0'; // eslint-disable-line functional/immutable-data
+    });
+
+    return;
+  }
+  // For other combinations we just can't be sure, so leave them as they are.
+}
+
+function getLanguages(record) {
+  const langFields = record.get('^041$');
+  if (langFields.length === 0) {
+    return [];
+  }
+  return langFields[0].subfields.filter(sf => isRelevantSubfield(sf)).map(subfield => subfield.value);
+  function isRelevantSubfield(subfield) {
+    if (subfield.code !== 'a' && subfield.code !== 'd') {
+      return false;
+    }
+    if (subfield.value.length !== 3) {
+      return false;
+    }
+    // We could require /^[a-z][a-z][a-z]$/ etc as well, but it's not really that relevant.
+    return true;
+  }
+}
+function recordNormalizeIndicators(record) {
+  recordNormalize490(record);
+
+  // Language is used to handle non-filing indicators
+  const languages = getLanguages(record);
+  record.fields.forEach(field => fieldNormalizeIndicators(field, record, languages));
+}
+function fieldNormalizeIndicators(field, record, languages) {
+  normalize245Indicator1(field, record);
+  normalizeNonFilingIndicator1(field, languages);
+  normalizeNonFilingIndicator2(field, languages);
+}
+//# sourceMappingURL=indicator-fixes.js.map

package/dist/indicator-fixes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indicator-fixes.js","names":["_utils","require","_default","description","validate","fix","record","res","message","valid","recordNormalizeIndicators","validateRecord","length","clonedFields","JSON","parse","stringify","fields","forEach","field","index","compareFields","origFieldAsString","fieldToString","ind1","push","ind2","ind1NonFilingChars","ind2NonFilingChars","hasNonFilingIndicator1","includes","tag","modifiableIndicatorValue","value","hasNonFilingIndicator2","valueBeginsWithDeterminer","cands","find","cand","substring","determineNonFilingIndicatorValue","languages","undefined","subfieldA","subfields","sf","code","name","toLowerCase","match","normalizeNonFilingIndicator1","normalizeNonFilingIndicator2","normalize245Indicator1","field1XX","get","recordNormalize490","fields490","fields8XX","f","getLanguages","langFields","filter","isRelevantSubfield","map","subfield","fieldNormalizeIndicators"],"sources":["../src/indicator-fixes.js"],"sourcesContent":["// Relocated from melinda-marc-record-merge-reducers (and renamed)\n//import createDebugLogger from 'debug';\n//const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:normalizeIdentifiers');\n\nimport {fieldToString} from './utils';\n\n\nexport default function () {\n\n  return {\n    description: 'Normalizes indicator values',\n    validate, fix\n  };\n\n  function fix(record) {\n    const res = {message: [], fix: [], valid: true};\n\n    recordNormalizeIndicators(record);\n\n    return res;\n  }\n\n  function validate(record) {\n    const res = {message: []};\n\n    validateRecord(record, res);\n\n    res.valid = res.message.length < 1; // eslint-disable-line functional/immutable-data\n    return res;\n  }\n\n\n  function validateRecord(record, res) {\n    //nvdebug(record);\n    const clonedFields = JSON.parse(JSON.stringify(record.fields));\n    recordNormalizeIndicators(record);\n\n    record.fields.forEach((field, index) => compareFields(field, index));\n\n    function compareFields(field, index) {\n      const origFieldAsString = fieldToString(clonedFields[index]);\n      //const clonedFieldAsString = fieldToString(field);\n      if (clonedFields[index].ind1 !== field.ind1) { // eslint-disable-line functional/no-conditional-statements\n        //nvdebug(`FIX IND1: '${clonedFields[index].ind1}' => '${field.ind1}': ${clonedFieldAsString}`);\n        res.message.push(`Expected IND1 for '${origFieldAsString}' is '${field.ind1}'`); // eslint-disable-line functional/immutable-data\n      }\n      if (clonedFields[index].ind2 !== field.ind2) { // eslint-disable-line functional/no-conditional-statements\n        //nvdebug(`FIX IND2: '${clonedFields[index].ind2}' => '${field.ind2}': ${clonedFieldAsString}`);\n        res.message.push(`Expected IND2 for '${origFieldAsString}' is '${field.ind2}'`); // eslint-disable-line functional/immutable-data\n      }\n    }\n    // Validator should not change the original record:\n    record.fields = clonedFields; // eslint-disable-line functional/immutable-data\n    return;\n  }\n}\n\n\nconst ind1NonFilingChars = ['130', '630', '730', '740'];\nconst ind2NonFilingChars = ['222', '240', '242', '243', '245', '830'];\n\nfunction hasNonFilingIndicator1(field) {\n  return ind1NonFilingChars.includes(field.tag);\n}\n\nfunction modifiableIndicatorValue(value) {\n  // If field contains a legit-looking value, don't try to modify it here...\n  return !['9', '8', '7', '6', '5', '4', '3', '2', '1'].includes(value);\n}\n\nfunction hasNonFilingIndicator2(field) {\n  return ind2NonFilingChars.includes(field.tag);\n}\n\nfunction valueBeginsWithDeterminer(value, cands) {\n  return cands.find(cand => value.substring(0, cand.length) === cand);\n}\n\nfunction determineNonFilingIndicatorValue(field, languages = undefined) {\n  const subfieldA = field.subfields.find(sf => sf.code === 'a');\n  if (!subfieldA) {\n    // nvdebug(' Subfield $a miss!');\n    return;\n  }\n\n  const name = subfieldA.value.toLowerCase();\n\n  if (languages.includes('eng')) {\n    const match = valueBeginsWithDeterminer(name, ['a ', 'an ', 'the ']);\n    if (match) {\n      return `${match.length}`;\n    }\n  }\n\n  if (languages.includes('fre')) {\n    const match = valueBeginsWithDeterminer(name, ['l\\'', 'le ']);\n    if (match) {\n      return `${match.length}`;\n    }\n  }\n\n  if (languages.includes('ger')) {\n    const match = valueBeginsWithDeterminer(name, ['das ', 'der ', 'die ']);\n    if (match) {\n      return `${match.length}`;\n    }\n  }\n\n  if (languages.includes('swe')) {\n    const match = valueBeginsWithDeterminer(name, ['en ', 'ett ']);\n    if (match) {\n      return `${match.length}`;\n    }\n  }\n\n  // Fallback-ish: try to guess even without languages:\n  const match = valueBeginsWithDeterminer(name, ['the ']);\n  if (match) {\n    return `${match.length}`;\n  }\n\n  return '0';\n}\n\nfunction normalizeNonFilingIndicator1(field, languages = []) {\n  if (!hasNonFilingIndicator1(field) || !modifiableIndicatorValue(field.ind1)) {\n    return;\n  }\n\n  field.ind1 = determineNonFilingIndicatorValue(field, languages); // eslint-disable-line functional/immutable-data\n}\n\nfunction normalizeNonFilingIndicator2(field, languages = []) {\n  if (!hasNonFilingIndicator2(field) || !modifiableIndicatorValue(field.ind2)) {\n    return;\n  }\n\n  field.ind2 = determineNonFilingIndicatorValue(field, languages); // eslint-disable-line functional/immutable-data\n}\n\n\nfunction normalize245Indicator1(field, record) {\n  if (field.tag !== '245') {\n    return;\n  }\n  const field1XX = record.get('^1..$');\n  field.ind1 = field1XX.length === 0 ? '0' : '1'; // eslint-disable-line functional/immutable-data\n}\n\n\nfunction recordNormalize490(record) {\n  const fields490 = record.get('^490$');\n  const fields8XX = record.get('^(?:800|810|811|830)$');\n\n  if (fields490.length === 0) {\n    return;\n  }\n  if (fields490.length <= fields8XX.length) {\n    // Trace found for each field 490:\n    fields490.forEach(f => {\n      f.ind1 = '1'; // eslint-disable-line functional/immutable-data\n    });\n    return;\n  }\n  if (fields8XX.length === 0) { // Fields 490 are always untraced (no traces found)\n    fields490.forEach(f => {\n      f.ind1 = '0'; // eslint-disable-line functional/immutable-data\n    });\n    return;\n  }\n  // For other combinations we just can't be sure, so leave them as they are.\n}\n\n\nfunction getLanguages(record) {\n  const langFields = record.get('^041$');\n\n  if (langFields.length === 0) {\n    return [];\n  }\n\n  return langFields[0].subfields.filter(sf => isRelevantSubfield(sf)).map(subfield => subfield.value);\n\n  function isRelevantSubfield(subfield) {\n    if (subfield.code !== 'a' && subfield.code !== 'd') {\n      return false;\n    }\n    if (subfield.value.length !== 3) {\n      return false;\n    }\n    // We could require /^[a-z][a-z][a-z]$/ etc as well, but it's not really that relevant.\n    return true;\n  }\n\n}\n\nexport function recordNormalizeIndicators(record) {\n  recordNormalize490(record);\n\n  // Language is used to handle non-filing indicators\n  const languages = getLanguages(record);\n\n  record.fields.forEach(field => fieldNormalizeIndicators(field, record, languages));\n\n}\n\nfunction fieldNormalizeIndicators(field, record, languages) {\n  normalize245Indicator1(field, record);\n  normalizeNonFilingIndicator1(field, languages);\n  normalizeNonFilingIndicator2(field, languages);\n}\n"],"mappings":"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"}

package/dist/indicator-fixes.spec.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _chai = require("chai");
+var _marcRecord = require("@natlibfi/marc-record");
+var _indicatorFixes = _interopRequireDefault(require("./indicator-fixes"));
+var _fixura = require("@natlibfi/fixura");
+var _fixugen = _interopRequireDefault(require("@natlibfi/fixugen"));
+var _debug = _interopRequireDefault(require("debug"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+(0, _fixugen.default)({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'indicator-fixes'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: _fixura.READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = (0, _debug.default)('@natlibfi/marc-record-validators-melinda/indicator-fixes:test');
+async function testValidatorFactory() {
+  const validator = await (0, _indicatorFixes.default)();
+  (0, _chai.expect)(validator).to.be.an('object').that.has.any.keys('description', 'validate');
+  (0, _chai.expect)(validator.description).to.be.a('string');
+  (0, _chai.expect)(validator.validate).to.be.a('function');
+}
+async function callback({
+  getFixture,
+  enabled = true,
+  fix = false
+}) {
+  if (enabled === false) {
+    debug('TEST SKIPPED!');
+    return;
+  }
+  const validator = await (0, _indicatorFixes.default)();
+  const record = new _marcRecord.MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    (0, _chai.expect)(result).to.eql(expectedResult);
+    return;
+  }
+  await validator.fix(record);
+  (0, _chai.expect)(record).to.eql(expectedResult);
+}
+//# sourceMappingURL=indicator-fixes.spec.js.map

package/dist/indicator-fixes.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indicator-fixes.spec.js","names":["_chai","require","_marcRecord","_indicatorFixes","_interopRequireDefault","_fixura","_fixugen","_debug","obj","__esModule","default","generateTests","callback","path","__dirname","useMetadataFile","recurse","fixura","reader","READERS","JSON","mocha","before","testValidatorFactory","debug","createDebugLogger","validator","validatorFactory","expect","to","be","an","that","has","any","keys","description","a","validate","getFixture","enabled","fix","record","MarcRecord","expectedResult","result","eql"],"sources":["../src/indicator-fixes.spec.js"],"sourcesContent":["import {expect} from 'chai';\nimport {MarcRecord} from '@natlibfi/marc-record';\nimport validatorFactory from './indicator-fixes';\nimport {READERS} from '@natlibfi/fixura';\nimport generateTests from '@natlibfi/fixugen';\nimport createDebugLogger from 'debug';\n\ngenerateTests({\n  callback,\n  path: [__dirname, '..', 'test-fixtures', 'indicator-fixes'],\n  useMetadataFile: true,\n  recurse: false,\n  fixura: {\n    reader: READERS.JSON\n  },\n  mocha: {\n    before: () => testValidatorFactory()\n  }\n});\nconst debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/indicator-fixes:test');\n\nasync function testValidatorFactory() {\n  const validator = await validatorFactory();\n\n  expect(validator)\n    .to.be.an('object')\n    .that.has.any.keys('description', 'validate');\n\n  expect(validator.description).to.be.a('string');\n  expect(validator.validate).to.be.a('function');\n}\n\nasync function callback({getFixture, enabled = true, fix = false}) {\n  if (enabled === false) {\n    debug('TEST SKIPPED!');\n    return;\n  }\n\n  const validator = await validatorFactory();\n  const record = new MarcRecord(getFixture('record.json'));\n  const expectedResult = getFixture('expectedResult.json');\n  // console.log(expectedResult); // eslint-disable-line\n\n  if (!fix) {\n    const result = await validator.validate(record);\n    expect(result).to.eql(expectedResult);\n    return;\n  }\n\n  await validator.fix(record);\n  expect(record).to.eql(expectedResult);\n}\n"],"mappings":";;AAAA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,OAAA,GAAAJ,OAAA;AACA,IAAAK,QAAA,GAAAF,sBAAA,CAAAH,OAAA;AACA,IAAAM,MAAA,GAAAH,sBAAA,CAAAH,OAAA;AAAsC,SAAAG,uBAAAI,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAEtC,IAAAG,gBAAa,EAAC;EACZC,QAAQ;EACRC,IAAI,EAAE,CAACC,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,iBAAiB,CAAC;EAC3DC,eAAe,EAAE,IAAI;EACrBC,OAAO,EAAE,KAAK;EACdC,MAAM,EAAE;IACNC,MAAM,EAAEC,eAAO,CAACC;EAClB,CAAC;EACDC,KAAK,EAAE;IACLC,MAAM,EAAEA,CAAA,KAAMC,oBAAoB,CAAC;EACrC;AACF,CAAC,CAAC;AACF,MAAMC,KAAK,GAAG,IAAAC,cAAiB,EAAC,+DAA+D,CAAC;AAEhG,eAAeF,oBAAoBA,CAAA,EAAG;EACpC,MAAMG,SAAS,GAAG,MAAM,IAAAC,uBAAgB,EAAC,CAAC;EAE1C,IAAAC,YAAM,EAACF,SAAS,CAAC,CACdG,EAAE,CAACC,EAAE,CAACC,EAAE,CAAC,QAAQ,CAAC,CAClBC,IAAI,CAACC,GAAG,CAACC,GAAG,CAACC,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC;EAE/C,IAAAP,YAAM,EAACF,SAAS,CAACU,WAAW,CAAC,CAACP,EAAE,CAACC,EAAE,CAACO,CAAC,CAAC,QAAQ,CAAC;EAC/C,IAAAT,YAAM,EAACF,SAAS,CAACY,QAAQ,CAAC,CAACT,EAAE,CAACC,EAAE,CAACO,CAAC,CAAC,UAAU,CAAC;AAChD;AAEA,eAAezB,QAAQA,CAAC;EAAC2B,UAAU;EAAEC,OAAO,GAAG,IAAI;EAAEC,GAAG,GAAG;AAAK,CAAC,EAAE;EACjE,IAAID,OAAO,KAAK,KAAK,EAAE;IACrBhB,KAAK,CAAC,eAAe,CAAC;IACtB;EACF;EAEA,MAAME,SAAS,GAAG,MAAM,IAAAC,uBAAgB,EAAC,CAAC;EAC1C,MAAMe,MAAM,GAAG,IAAIC,sBAAU,CAACJ,UAAU,CAAC,aAAa,CAAC,CAAC;EACxD,MAAMK,cAAc,GAAGL,UAAU,CAAC,qBAAqB,CAAC;EACxD;;EAEA,IAAI,CAACE,GAAG,EAAE;IACR,MAAMI,MAAM,GAAG,MAAMnB,SAAS,CAACY,QAAQ,CAACI,MAAM,CAAC;IAC/C,IAAAd,YAAM,EAACiB,MAAM,CAAC,CAAChB,EAAE,CAACiB,GAAG,CAACF,cAAc,CAAC;IACrC;EACF;EAEA,MAAMlB,SAAS,CAACe,GAAG,CAACC,MAAM,CAAC;EAC3B,IAAAd,YAAM,EAACc,MAAM,CAAC,CAACb,EAAE,CAACiB,GAAG,CAACF,cAAc,CAAC;AACvC"}