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

package/dist/candidate-search/query-list/bib.js

@@ -1,101 +1,34 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.bibAuthors = bibAuthors;
-exports.bibHostComponents = bibHostComponents;
-exports.bibMelindaIds = bibMelindaIds;
-exports.bibPublishers = bibPublishers;
-exports.bibSourceIds = bibSourceIds;
-exports.bibStandardIdentifiers = bibStandardIdentifiers;
-exports.bibTitle = bibTitle;
-exports.bibTitleAuthor = bibTitleAuthor;
-exports.bibTitleAuthorPublisher = bibTitleAuthorPublisher;
-exports.bibTitleAuthorYear = bibTitleAuthorYear;
-exports.bibYear = bibYear;
-var _debug = _interopRequireDefault(require("debug"));
-var _candidateSearchUtils = require("../candidate-search-utils");
-var _matchingUtils = require("../../matching-utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of melinda-record-matching-js
-*
-* melinda-record-matching-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* melinda-record-matching-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
-
-const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query');
-function bibSourceIds(record) {
-  /* Melinda's SRU-index melinda.sourceid includes source IDs from SID fields in Melinda records
-     SID-fields in Melinda have sf $c with local id and sf $b with a code for the local db:
-      SID__ $c 123457 $b helka
-     SID__ $c (ANDL100020)1077305 $b sata
-     SID__ $c VER999999 $ FI-KV
-     SID__ $c /10024/508126 $ REPO_THESEUS
-     In melinda.sourceid -index case is kept, sourceprefixes in brackets and hyphens are normalized away:
-    Note: slashes are not normalized away, but a SRU-search-string including slashes needs to be quoted
-     1234567helka
-    1077305sata
-    VER999999FIKV
-    /10024/508126REPO_THESEUS
-     Note: All Melinda records that have a matching records in a local db do NOT have SID for that local records,
-          existence of a SID field depends on how the record has been added to Melinda and how it has been handled
-          afterwards. SIDs are also not reliably maintained. A record might or might not have a SID for a local db
-          after the matching record is removed from the local db.
-    */
-
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query:source-ids');
-  const debugData = debug.extend('data');
-  //const debugInfo = debug.extend('info');
-
-  debug(`Creating queries for sourceid's`);
-  const fSids = record.get('SID');
+import createDebugLogger from "debug";
+import { toQueries } from "../candidate-search-utils.js";
+import { getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber } from "../../matching-utils.js";
+const debug = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query");
+export function bibSourceIds(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:source-ids");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for sourceid's`);
+  const fSids = record.get("SID");
   debugData(`SID-fields (${fSids.length}): ${JSON.stringify(fSids)}`);
   return fSids.length > 0 ? toSidQueries(fSids) : [];
-  function toSidQueries(fSids) {
-    debug(`Creating actual queries for sourceid's`);
-    const sidStrings = getSidStrings(fSids);
+  function toSidQueries(fSids2) {
+    debug2(`Creating actual queries for sourceid's`);
+    const sidStrings = getSidStrings(fSids2);
     if (sidStrings.length < 1) {
-      debug(`No identifiers found, no queries created.`);
+      debug2(`No identifiers found, no queries created.`);
       return [];
     }
-    const sidQueries = (0, _candidateSearchUtils.toQueries)(sidStrings, 'melinda.sourceid');
+    const sidQueries = toQueries(sidStrings, "melinda.sourceid");
     return sidQueries;
-    function getSidStrings(fSids) {
-      debug(`Getting Sid strings from SID fields`);
-
-      // Map SID fields to valid sidStrings, filter out empty strings
-      const sidStrings = fSids.map(toSidString).filter(nonEmptySid => nonEmptySid);
-      return sidStrings;
+    function getSidStrings(fSids3) {
+      debug2(`Getting Sid strings from SID fields`);
+      const sidStrings2 = fSids3.map(toSidString).filter((nonEmptySid) => nonEmptySid);
+      return sidStrings2;
       function toSidString(field) {
-        debug(`Getting string from a field`);
-        return (0, _matchingUtils.validateSidFieldSubfieldCounts)(field) ? createSidString(field) : '';
-        function createSidString(field) {
-          debug(`Creating string from a field`);
-          const [sfC] = (0, _matchingUtils.getSubfieldValues)(field, 'c');
-          const [sfB] = (0, _matchingUtils.getSubfieldValues)(field, 'b');
+        debug2(`Getting string from a field`);
+        return validateSidFieldSubfieldCounts(field) ? createSidString(field) : "";
+        function createSidString(field2) {
+          debug2(`Creating string from a field`);
+          const [sfC] = getSubfieldValues(field2, "c");
+          const [sfB] = getSubfieldValues(field2, "b");
           const cleanedSfC = removeSourcePrefix(normalizeSidSubfieldValue(sfC));
           const cleanedSfB = normalizeSidSubfieldValue(sfB);
           debugData(`${JSON.stringify(sfC)} + ${JSON.stringify(sfB)}`);
@@ -103,307 +36,204 @@ function bibSourceIds(record) {
         }
         function removeSourcePrefix(subfieldValue) {
           const sourcePrefixRegex = /^(?<sourcePrefix>\([A-Za-z0-9-]+\))(?<id>.+)$/u;
-          const normalizedValue = (0, _matchingUtils.testStringOrNumber)(subfieldValue) ? String(subfieldValue).replace(sourcePrefixRegex, '$<id>') : '';
+          const normalizedValue = testStringOrNumber(subfieldValue) ? String(subfieldValue).replace(sourcePrefixRegex, "$<id>") : "";
           debugData(`Normalized ${subfieldValue} to ${normalizedValue}`);
           return normalizedValue;
         }
         function normalizeSidSubfieldValue(subfieldValue) {
           debugData(`Normalizing ${subfieldValue}`);
           const normalizeAwayRegex = /[- ]/u;
-          return (0, _matchingUtils.testStringOrNumber)(subfieldValue) ? String(subfieldValue).replace(normalizeAwayRegex, '') : '';
+          return testStringOrNumber(subfieldValue) ? String(subfieldValue).replace(normalizeAwayRegex, "") : "";
         }
       }
     }
   }
 }
-function bibMelindaIds(record) {
-  // Melinda's SRU-index melinda.melindaid includes f001 controlnumbers and old Melinda-IDs from f035z's for all non-deleted Melinda-records
-
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query:bibMelindaIds');
-  const debugData = debug.extend('data');
-  debug(`Creating queries for MelindaIds`);
-
-  // Note: Melinda-ID's for search queries are created just from records f035a's and f035z's
-  // Both (FI-MELINDA)- and FCC-prefixed forms are found
-  // f001 controlnumber is not currently included, even if record's f003 is FI-MELINDA
-  const melindaIds = (0, _matchingUtils.getMelindaIdsF035)(record);
+export function bibMelindaIds(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibMelindaIds");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for MelindaIds`);
+  const melindaIds = getMelindaIdsF035(record);
   debugData(`Unique identifiers (${melindaIds.length}): ${JSON.stringify(melindaIds)}`);
   if (melindaIds.length < 1) {
-    debug(`No identifiers found, no queries created.`);
+    debug2(`No identifiers found, no queries created.`);
     return [];
   }
-  return (0, _candidateSearchUtils.toQueries)(melindaIds, 'melinda.melindaid');
+  return toQueries(melindaIds, "melinda.melindaid");
 }
-
-// bibHostComponents returns host id from the first subfield $w of first field f773, see test-fixtures 04 and 05
-// bibHostComponents should search all 773 $ws for possible host id, but what should it do in case of multiple host ids?
-function bibHostComponents(record) {
+export function bibHostComponents(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for hostIds`);
   const id = getHostId();
-  return (0, _matchingUtils.testStringOrNumber)(id) ? [`melinda.partsofhost=${id}`] : [];
+  debugData(`Found id: ${JSON.stringify(id)}`);
+  return testStringOrNumber(id) ? [`melinda.partsofhost=${id}`] : [];
   function getHostId() {
     const [field] = record.get(/^773$/u);
     if (field) {
-      const {
-        value
-      } = field.subfields.find(({
-        code
-      }) => code === 'w') || {};
-      if ((0, _matchingUtils.testStringOrNumber)(value) && /^\(FI-MELINDA\)/u.test(String(value))) {
-        return String(value).replace(/^\(FI-MELINDA\)/u, '');
+      const { value } = field.subfields.find(({ code }) => code === "w") || {};
+      if (testStringOrNumber(value) && /^\(FI-MELINDA\)/u.test(String(value))) {
+        return String(value).replace(/^\(FI-MELINDA\)/u, "");
       }
-      if ((0, _matchingUtils.testStringOrNumber)(value) && /^\(FIN01\)/u.test(String(value))) {
-        return String(value).replace(/^\(FIN01\)/u, '');
+      if (testStringOrNumber(value) && /^\(FIN01\)/u.test(String(value))) {
+        return String(value).replace(/^\(FIN01\)/u, "");
       }
       return false;
     }
     return false;
   }
 }
-
-// SRU search dc.title with a search phrase starting with ^ maps currently in Melinda to
-// (probably) to *headings* index TIT
-// - Aleph cannot currently handle headings searches starting with a boolean - in these cases use word search
-
-// Headings index TIT drops articles etc. from the start of the title according to the filing indicator
-// Currently filing indicator is not implemented - if the title starts with an article and the Melinda
-// record is correctly catalogued using a filing indicator -> dc.title search won't match
-
-function bibTitle(record) {
-  // We get author/publisher only when formatted title is shorter than 5 chars
-  return bibTitleAuthorPublisher({
-    record,
-    onlyTitleLength: 5
-  });
+export function bibTitle(record) {
+  return bibTitleAuthorPublisher({ record, onlyTitleLength: 5 });
 }
-function bibTitleAuthor(record) {
-  debug('bibTitleAuthor');
-  // We use onlyTitleLength that is longer than our formatted length to
-  // get an author or an publisher always
-  return bibTitleAuthorPublisher({
-    record,
-    onlyTitleLength: 100
-  });
+export function bibTitleAuthor(record) {
+  debug("bibTitleAuthor");
+  return bibTitleAuthorPublisher({ record, onlyTitleLength: 100 });
 }
-function bibTitleAuthorYear(record) {
-  debug('bibTitleAuthorYear');
-  // We use onlyTitleLength that is longer than our formatted length to
-  // get an author or an publisher always
-
-  return bibTitleAuthorPublisher({
-    record,
-    onlyTitleLength: 100,
-    addYear: true
-  });
+export function bibTitleAuthorYear(record) {
+  debug("bibTitleAuthorYearAlternates");
+  return bibTitleAuthorPublisher({ record, onlyTitleLength: 100, addYear: true });
 }
-function bibTitleAuthorPublisher({
-  record,
-  onlyTitleLength,
-  addYear = false
-}) {
-  debug('bibTitleAuthorPublisher');
+export function bibTitleAuthorYearAlternates(record) {
+  debug("bibTitleAuthorYearAlternates");
+  const origQueryList = bibTitleAuthorPublisher({ record, onlyTitleLength: 100, addYear: true, alternates: true, alternateQueries: [] });
+  debug(`${JSON.stringify(origQueryList)}`);
+  return { queryList: Array.from(origQueryList).reverse(), queryListType: "alternates" };
+}
+export function bibTitleAuthorPublisher({ record, onlyTitleLength, addYear = false, alternates = false, alternateQueries = [] }) {
+  debug(`bibTitleAuthorPublisher, onlyTitleLength: ${onlyTitleLength}, addYear: ${addYear}, alternates: ${alternates}`);
   const title = getTitle();
-  const booleanStartWords = ['and', 'or', 'nor', 'not'];
-  if ((0, _matchingUtils.testStringOrNumber)(title)) {
-    const formatted = String(title).replace(/[^\w\s\p{Alphabetic}]/gu, '')
-    // Clean up concurrent spaces from fe. subfield changes
-    .replace(/ +/gu, ' ').trim().slice(0, 30).trim();
-
-    // use word search for titles starting with a boolean
-    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
-    // Prevent too many matches / SRU crashing by having a minimum length
-    // Note that currently this fails matching if there are no matches from previous matchers
-    if (formatted.length >= onlyTitleLength) {
-      return [`dc.title="${useWordSearch ? '' : '^'}${formatted}*"`];
+  if (testStringOrNumber(title)) {
+    const formatted = String(title).replace(/[^\w\s\p{Alphabetic}]/gu, "").replace(/ +/gu, " ").trim().slice(0, 30).trim();
+    const useWordSearch = checkUseWordSearch(formatted);
+    if (formatted.length >= onlyTitleLength && !alternates) {
+      return [`dc.title="${useWordSearch ? "" : "^"}${formatted}*"`];
     }
     const queryIsOkAlone = formatted.length >= 5;
-
-    // use word search without ending * also in combination searches to avoid SRU-server crashes [MRA-189]
-    const query = `dc.title="${useWordSearch || !queryIsOkAlone ? '' : '^'}${formatted}${queryIsOkAlone ? '*' : ''}"`;
+    const query = `dc.title="${useWordSearch || !queryIsOkAlone ? "" : "^"}${formatted}${queryIsOkAlone ? "*" : ""}"`;
     debug(`query: ${query}`);
-    return addAuthorsToSearch({
-      query,
-      queryIsOkAlone,
-      addYear
-    });
+    const newAlternateQueries = alternates ? [...alternateQueries, query] : alternateQueries;
+    return addAuthorsToSearch({ query, queryIsOkAlone, addYear, alternates, alternateQueries: newAlternateQueries });
   }
   return [];
-  function addAuthorsToSearch({
-    query,
-    queryIsOkAlone = false,
-    addYear = false
-  }) {
-    debug('addAuthorsToSearch');
+  function addAuthorsToSearch({ query, queryIsOkAlone = false, addYear: addYear2 = false, alternates: alternates2 = false, alternateQueries: alternateQueries2 = [] }) {
+    debug("addAuthorsToSearch");
     const [authorQuery] = bibAuthors(record);
-    if (authorQuery !== undefined) {
-      if (addYear) {
-        return addYearToSearch({
-          query: `${authorQuery} AND ${query}`,
-          queryIsOkAlone: true
-        });
+    if (authorQuery !== void 0) {
+      if (addYear2) {
+        const newAlternateQueries = alternates2 ? [...alternateQueries2, `${authorQuery} AND ${query}`] : alternateQueries2;
+        return addYearToSearch({ query: `${authorQuery} AND ${query}`, queryIsOkAlone: true, alternates: alternates2, alternateQueries: newAlternateQueries });
       }
-      return [`${authorQuery} AND ${query}`];
+      return alternates2 ? alternateQueries2 : [`${authorQuery} AND ${query}`];
     }
-    return addPublisherToSearch({
-      query,
-      queryIsOkAlone,
-      addYear
-    });
-    //return [];
+    return addPublisherToSearch({ query, queryIsOkAlone, addYear: addYear2, alternates: alternates2, alternateQueries: alternateQueries2 });
   }
-
-  function addPublisherToSearch({
-    query,
-    queryIsOkAlone = false,
-    addYear = false
-  }) {
+  function addPublisherToSearch({ query, queryIsOkAlone = false, addYear: addYear2 = false, alternates: alternates2 = false, alternateQueries: alternateQueries2 = [] }) {
     const [publisherQuery] = bibPublishers(record);
-    if (publisherQuery !== undefined) {
-      if (addYear) {
-        return addYearToSearch({
-          query: `${publisherQuery} AND ${query}`,
-          queryIsOkAlone: true
-        });
+    if (publisherQuery !== void 0) {
+      if (addYear2) {
+        const newAlternateQueries = alternates2 ? [...alternateQueries2, `${publisherQuery} AND ${query}`] : alternateQueries2;
+        return addYearToSearch({ query: `${publisherQuery} AND ${query}`, queryIsOkAlone: true, alternates: alternates2, alternateQueries: newAlternateQueries });
       }
-      return [`${publisherQuery} AND ${query}`];
+      return alternates2 ? alternateQueries2 : [`${publisherQuery} AND ${query}`];
     }
-    if (queryIsOkAlone && !addYear) {
-      return [`${query}`];
+    if (queryIsOkAlone && !addYear2) {
+      return alternates2 ? alternateQueries2 : [`${query}`];
     }
-    return addYearToSearch({
-      query,
-      queryIsOkAlone
-    });
+    return addYearToSearch({ query, queryIsOkAlone, alternates: alternates2, alternateQueries: alternateQueries2 });
   }
-  function addYearToSearch({
-    query,
-    queryIsOkAlone = false
-  }) {
+  function addYearToSearch({ query, queryIsOkAlone = false, alternates: alternates2 = false, alternateQueries: alternateQueries2 = [] }) {
     const [yearQuery] = bibYear(record);
-    if (yearQuery !== undefined) {
-      return [`${yearQuery} AND ${query}`];
+    if (yearQuery !== void 0) {
+      const newAlternateQueries = alternates2 ? [...alternateQueries2, `${yearQuery} AND ${query}`] : alternateQueries2;
+      return alternates2 ? newAlternateQueries : [`${yearQuery} AND ${query}`];
     }
     if (queryIsOkAlone) {
-      return [`${query}`];
+      return alternates2 ? alternateQueries2 : [`${query}`];
     }
     return [];
   }
   function getTitle() {
     const [field] = record.get(/^245$/u);
     if (field) {
-      const titleString = field.subfields
-      //.filter(({code}) => ['a', 'b', 'n', 'p'].includes(code))
-      .filter(({
-        code
-      }) => ['a', 'b'].includes(code))
-      //.filter(({code}) => ['a'].includes(code))
-      .map(({
-        value
-      }) => (0, _matchingUtils.testStringOrNumber)(value) ? String(value) : '').filter(value => value)
-      // In Melinda's index subfield separators are indexed as ' '
-      .join(' ');
+      const titleString = field.subfields.filter(({ code }) => ["a", "b"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value).join(" ");
       return titleString;
     }
     return false;
   }
 }
-function bibAuthors(record) {
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query:bibAuthors');
-  const debugData = debug.extend('data');
-  debug(`Creating query for the first author`);
-  //debugData(record);
-
+export function bibAuthors(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibAuthors");
+  const debugData = debug2.extend("data");
+  debug2(`Creating query for the first author`);
   const author = getAuthor(record);
-  const booleanStartWords = ['and', 'or', 'nor', 'not'];
-  if ((0, _matchingUtils.testStringOrNumber)(author)) {
-    const formatted = String(author).replace(/[^\w\s\p{Alphabetic}]/gu, '')
-    // Clean up concurrent spaces from fe. subfield changes
-    .replace(/ +/gu, ' ').trim().slice(0, 30).trim();
-
-    // use word search for authors starting with a boolean
-    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
-    // Prevent too many matches by having a minimum length
+  if (testStringOrNumber(author)) {
+    const formatted = String(author).replace(/[^\w\s\p{Alphabetic}]/gu, "").replace(/ +/gu, " ").trim().slice(0, 30).trim();
+    const useWordSearch = checkUseWordSearch(formatted);
     debugData(`Author string: ${formatted}`);
     if (formatted.length >= 5) {
-      return [`dc.author="${useWordSearch ? '' : '^'}${formatted}*"`];
+      return [`dc.author="${useWordSearch ? "" : "^"}${formatted}*"`];
     }
     return [];
   }
   return [];
-  function getAuthor(record) {
-    //debugData(record);
-    // eslint-disable-next-line prefer-named-capture-group
-    const [field] = record.get(/^(100)|(110)|(111)|(700)|(710)|(711)$/u);
-    //debugData(field);
-
+  function getAuthor(record2) {
+    const [field] = record2.get(/^(100)|(110)|(111)|(700)|(710)|(711)$/u);
     if (field) {
-      const authorString = field.subfields.filter(({
-        code
-      }) => ['a'].includes(code)).map(({
-        value
-      }) => (0, _matchingUtils.testStringOrNumber)(value) ? String(value) : '').filter(value => value)
-      // In Melinda's index subfield separators are indexed as ' '
-      .join(' ');
+      const authorString = field.subfields.filter(({ code }) => ["a"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value).join(" ");
       return authorString;
     }
     return false;
   }
 }
-function bibPublishers(record) {
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query:bibPublishers');
-  const debugData = debug.extend('data');
-  debug(`Creating query for the first publisher`);
-  //debugData(record);
-
+export function bibPublishers(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibPublishers");
+  const debugData = debug2.extend("data");
+  debug2(`Creating query for the first publisher`);
   const publisher = getPublisher(record);
-  if ((0, _matchingUtils.testStringOrNumber)(publisher)) {
-    const formatted = String(publisher).replace(/[^\w\s\p{Alphabetic}]/gu, '')
-    // Clean up concurrent spaces from fe. subfield changes
-    .replace(/ +/gu, ' ').trim().slice(0, 30).trim();
+  if (testStringOrNumber(publisher)) {
+    const formatted = String(publisher).replace(/[^\w\s\p{Alphabetic}]/gu, "").replace(/ +/gu, " ").trim().slice(0, 30).trim();
     debugData(`Publisher string: ${formatted}`);
-    // use non-wildcard word search from dc.publisher
     return [`dc.publisher="${formatted}"`];
   }
   return [];
-  function getPublisher(record) {
-    //debugData(record);
-    const [field] = record.get(/^(?:260)|(?:264)$/u);
-    //debugData(field);
-
+  function getPublisher(record2) {
+    const [field] = record2.get(/^(?:260)|(?:264)$/u);
     if (field) {
-      const publisherString = field.subfields.filter(({
-        code
-      }) => ['b'].includes(code)).map(({
-        value
-      }) => (0, _matchingUtils.testStringOrNumber)(value) ? String(value) : '').filter(value => value)
-      // In Melinda's index subfield separators are indexed as ' '
-      .join(' ');
+      const publisherString = field.subfields.filter(({ code }) => ["b"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value).join(" ");
       return publisherString;
     }
     return false;
   }
 }
-function bibYear(record) {
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query:bibYear');
-  const debugData = debug.extend('data');
-  debug(`Creating query for the publishing year`);
-  debugData(record);
+export function bibYear(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibYear");
+  const debugData = debug2.extend("data");
+  debug2(`Creating query for the publishing year`);
   const year = getYear(record);
   if (year) {
     return [`dc.date="${year}"`];
   }
   return [];
-  function getYear(record) {
-    const value = record.get(/^008$/u)?.[0]?.value || undefined;
-    return (0, _matchingUtils.testStringOrNumber)(value) ? String(value).slice(7, 11) : undefined;
+  function getYear(record2) {
+    const [f008] = record2.get(/^008$/u);
+    if (f008 === void 0) {
+      debug2("f008 missing");
+      return false;
+    }
+    debugData(`f008: ${JSON.stringify(f008)}`);
+    const { value } = f008;
+    return testStringOrNumber(value) ? String(value).slice(7, 11) : void 0;
   }
 }
-function bibStandardIdentifiers(record) {
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:candidate-search:query:bibStandardIdentifiers');
-  const debugData = debug.extend('data');
-  debug(`Creating queries for standard identifiers`);
-
-  // DEVELOP: should we query also f015 and f028?
-
+export function checkUseWordSearch(formatted) {
+  const booleanStartWords = ["and ", "or ", "nor ", "not "];
+  return booleanStartWords.some((word) => formatted.toLowerCase().startsWith(word));
+}
+export function bibStandardIdentifiers(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibStandardIdentifiers");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for standard identifiers`);
   const fields = record.get(/^(?<def>020|022|024)$/u);
   const identifiers = [].concat(...fields.map(toIdentifiers));
   const uniqueIdentifiers = [...new Set(identifiers)];
@@ -411,29 +241,20 @@ function bibStandardIdentifiers(record) {
   debugData(`Identifiers (${identifiers.length}): ${JSON.stringify(identifiers)}`);
   debugData(`Unique identifiers (${uniqueIdentifiers.length}): ${JSON.stringify(uniqueIdentifiers)}`);
   if (uniqueIdentifiers.length < 1) {
-    debug(`No identifiers found, no queries created.`);
+    debug2(`No identifiers found, no queries created.`);
     return [];
   }
-  return (0, _candidateSearchUtils.toQueries)(uniqueIdentifiers, 'dc.identifier');
-  function toIdentifiers({
-    tag,
-    subfields
-  }) {
+  return toQueries(uniqueIdentifiers, "dc.identifier");
+  function toIdentifiers({ tag, subfields }) {
     const issnIsbnReqExp = /^[A-Za-z0-9-]+$/u;
     const otherIdReqExp = /^[A-Za-z0-9-:]+$/u;
-    if (tag === '022') {
-      return subfields.filter(sub => ['a', 'z', 'y'].includes(sub.code) && (0, _matchingUtils.testStringOrNumber)(sub.value) && issnIsbnReqExp.test(String(sub.value))).map(({
-        value
-      }) => String(value));
+    if (tag === "022") {
+      return subfields.filter((sub) => ["a", "z", "y"].includes(sub.code) && testStringOrNumber(sub.value) && issnIsbnReqExp.test(String(sub.value))).map(({ value }) => String(value));
     }
-    if (tag === '020') {
-      return subfields.filter(sub => ['a', 'z'].includes(sub.code) && (0, _matchingUtils.testStringOrNumber)(sub.value) && issnIsbnReqExp.test(String(sub.value))).map(({
-        value
-      }) => String(value));
+    if (tag === "020") {
+      return subfields.filter((sub) => ["a", "z"].includes(sub.code) && testStringOrNumber(sub.value) && issnIsbnReqExp.test(String(sub.value))).map(({ value }) => String(value));
     }
-    return subfields.filter(sub => ['a', 'z'].includes(sub.code) && (0, _matchingUtils.testStringOrNumber)(sub.value) && otherIdReqExp.test(String(sub.value))).map(({
-      value
-    }) => String(value));
+    return subfields.filter((sub) => ["a", "z"].includes(sub.code) && testStringOrNumber(sub.value) && otherIdReqExp.test(String(sub.value))).map(({ value }) => String(value));
   }
 }
-//# sourceMappingURL=bib.js.map
+//# sourceMappingURL=bib.js.map