fhirsmith 0.16.1 → 0.18.0

package/tx/cs/cs-cs.js

@@ -19,6 +19,63 @@ const regexUtilities = require("../../library/regex-utilities");
 // filter results do not depend on forIteration, so one form is stored per version.
 const FILTER_ANALYSIS = Symbol('filterAnalysis');
 
+// The texts of each concept as a text filter compares them, by concept. Folding is
+// the costly part of a search over a large code system, so it is done once per
+// concept, and dropped with the code system.
+const SEARCH_TEXTS = new WeakMap();
+
+/**
+ * Lower case without accents, so "colera" finds "Cólera". Only marks on Latin, Greek and
+ * Cyrillic letters are accents: in other scripts, such as kana or Devanagari, marks are
+ * part of how a word is spelt, and dropping them would make "がん" find "かん".
+ */
+function foldSearchText(text) {
+  return text.normalize('NFD')
+    .replace(/([\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}])\p{M}+/gu, '$1')
+    .toLowerCase();
+}
+
+/**
+ * A text as a text filter compares it: `text` folded, and `words` the same with each
+ * run of other characters made one space and a space in front, so that " " + word
+ * finds where a word starts.
+ */
+function searchText(text) {
+  const folded = foldSearchText(text);
+  return { text: folded, words: ' ' + folded.replace(/[^\p{L}\p{N}]+/gu, ' ') };
+}
+
+function conceptSearchTexts(concept) {
+  let texts = SEARCH_TEXTS.get(concept);
+  if (texts === undefined) {
+    texts = {
+      code: foldSearchText(concept.code),
+      display: concept.display ? searchText(concept.display) : null,
+      definition: concept.definition ? foldSearchText(concept.definition) : null,
+      designations: Array.isArray(concept.designation)
+        ? concept.designation.filter(designation => designation.value).map(designation => searchText(designation.value))
+        : []
+    };
+    SEARCH_TEXTS.set(concept, texts);
+  }
+  return texts;
+}
+
+/**
+ * Whether every word starts a word of the text.
+ */
+function startsWords(text, words) {
+  return words.every(word => text.words.includes(' ' + word));
+}
+
+/**
+ * How much of the text the words cover, from 0 to 1, counting one space between words
+ * whatever separated them in the search.
+ */
+function wordsRatio(words, text) {
+  return Math.min(1, words.join(' ').length / text.text.length);
+}
+
 /**
  * Context class for FHIR CodeSystem provider concepts
  */
@@ -114,7 +171,35 @@ class FhirCodeSystemProviderFilterContext {
   }
 }
 
+// Code systems loaded as ordinary CodeSystem resources (from a package, or supplied by a
+// client) that need behaviour beyond the resource: a grammar, say. Keyed on the CodeSystem
+// url; the class extends FhirCodeSystemProvider, so the content still comes from the
+// resource. Required lazily, because the subclasses require this module.
+let specialisedProviders = null;
+
+function providerClassFor(url) {
+  if (specialisedProviders === null) {
+    specialisedProviders = new Map([
+      ['http://hl7.org/fhir/sid/icf', require('./cs-icf').IcfCodeSystemProvider]
+    ]);
+  }
+  return specialisedProviders.get(url) || FhirCodeSystemProvider;
+}
+
 class FhirCodeSystemProvider extends BaseCSServices {
+  /**
+   * The provider for a CodeSystem resource: a FhirCodeSystemProvider, or the subclass
+   * registered for its url. Always use this rather than the constructor.
+   * @param {OperationContext} opContext
+   * @param {CodeSystem} codeSystem
+   * @param {CodeSystem[]} supplements
+   * @returns {FhirCodeSystemProvider}
+   */
+  static create(opContext, codeSystem, supplements) {
+    const cls = providerClassFor(codeSystem.url);
+    return new cls(opContext, codeSystem, supplements);
+  }
+
   /**
    * @param {CodeSystem} codeSystem - The primary CodeSystem
    * @param {CodeSystem[]} supplements - Array of supplement CodeSystems
@@ -140,6 +225,33 @@ class FhirCodeSystemProvider extends BaseCSServices {
     return this.codeSystem.jsonObj.name || '';
   }
 
+  /**
+   * $lookup's display name: CodeSystem.title, translated where the resource carries a
+   * translation for one of the request's languages, else the title as written, else name.
+   * @param {Languages} [languages] - the request's working languages
+   * @returns {string}
+   */
+  lookupName(languages) {
+    const cs = this.codeSystem.jsonObj;
+    if (!cs.title) return this.name();
+    const base = (c) => String(c || '').toLowerCase().split('-')[0];
+    const translations = (cs._title?.extension || [])
+      .filter(e => e.url === 'http://hl7.org/fhir/StructureDefinition/translation')
+      .map(e => ({
+        lang: (e.extension || []).find(x => x.url === 'lang')?.valueCode,
+        content: (e.extension || []).find(x => x.url === 'content')?.valueString,
+      }))
+      .filter(t => t.lang && t.content);
+    for (const l of languages || []) {
+      const want = base(l.language || l.code);
+      if (!want) continue;
+      if (cs.language && base(cs.language) === want) return cs.title;
+      const t = translations.find(t => base(t.lang) === want);
+      if (t) return t.content;
+    }
+    return cs.title;
+  }
+
   /**
    * @returns {string} URI for the code system
    */
@@ -1145,14 +1257,15 @@ class FhirCodeSystemProvider extends BaseCSServices {
     
 
     const results = new FhirCodeSystemProviderFilterContext();
-    const searchTerm = filter.filter.toLowerCase();
+    const searchTerm = foldSearchText(filter.filter);
+    const searchWords = searchTerm.split(/[^\p{L}\p{N}]+/u).filter(word => word !== '');
 
     // Search through all concepts
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
       this.opContext.deadCheck('cs:searchFilter');
-      const rating = this._calculateSearchRating(concept, searchTerm);
+      const rating = this._calculateSearchRating(concept, searchTerm, searchWords);
       if (rating > 0) {
         results.add(concept, rating);
       }
@@ -1174,47 +1287,57 @@ class FhirCodeSystemProvider extends BaseCSServices {
   /**
    * Calculate search relevance rating for a concept
    * @param {Object} concept - The concept to rate
-   * @param {string} searchTerm - The search term (lowercase)
+   * @param {string} searchTerm - The search term (folded: lower case, no accents)
+   * @param {string[]} searchWords - The words of the search term
    * @returns {number} Rating (0 = no match, higher = better match)
    * @private
    */
-  _calculateSearchRating(concept, searchTerm) {
+  _calculateSearchRating(concept, searchTerm, searchWords) {
+    const texts = conceptSearchTexts(concept);
+    const display = texts.display;
     let rating = 0;
 
     // Exact matches get highest rating
-    if (concept.code.toLowerCase() === searchTerm) {
+    if (texts.code === searchTerm) {
       rating = 100;
-    } else if (concept.display && concept.display.toLowerCase() === searchTerm) {
+    } else if (display && display.text === searchTerm) {
       rating = 100;
     }
     // Code starts with search term
-    else if (concept.code.toLowerCase().startsWith(searchTerm)) {
+    else if (texts.code.startsWith(searchTerm)) {
       rating = 90;
     }
     // Display starts with search term
-    else if (concept.display && concept.display.toLowerCase().startsWith(searchTerm)) {
-      const lengthRatio = searchTerm.length / concept.display.length;
+    else if (display && display.text.startsWith(searchTerm)) {
+      const lengthRatio = searchTerm.length / display.text.length;
       rating = 80 + (10 * lengthRatio);
     }
     // Code contains search term
-    else if (concept.code.toLowerCase().includes(searchTerm)) {
+    else if (texts.code.includes(searchTerm)) {
       rating = 60;
     }
     // Display contains search term
-    else if (concept.display && concept.display.toLowerCase().includes(searchTerm)) {
+    else if (display && display.text.includes(searchTerm)) {
       rating = 50;
     }
     // Definition contains search term
-    else if (concept.definition && concept.definition.toLowerCase().includes(searchTerm)) {
+    else if (texts.definition && texts.definition.includes(searchTerm)) {
       rating = 30;
     }
     // Check designations
-    else if (concept.designation && Array.isArray(concept.designation)) {
-      for (const designation of concept.designation) {
-        if (designation.value && designation.value.toLowerCase().includes(searchTerm)) {
-          rating = 40;
-          break;
-        }
+    else if (texts.designations.some(designation => designation.text.includes(searchTerm))) {
+      rating = 40;
+    }
+    // Each word of a search of several starts a word of the display, in any order;
+    // the shorter the display, the closer the match
+    else if (searchWords.length > 1 && display && startsWords(display, searchWords)) {
+      rating = 20 + (10 * wordsRatio(searchWords, display));
+    }
+    // Or of one designation
+    else if (searchWords.length > 1) {
+      const designation = texts.designations.find(designation => startsWords(designation, searchWords));
+      if (designation) {
+        rating = 10 + (10 * wordsRatio(searchWords, designation));
       }
     }
 
@@ -1679,7 +1802,7 @@ class FhirCodeSystemFactory extends CodeSystemFactoryProvider {
       });
     }
 
-    return new FhirCodeSystemProvider(opContext, codeSystem, supplements);
+    return FhirCodeSystemProvider.create(opContext, codeSystem, supplements);
   }
 
   // eslint-disable-next-line no-unused-vars