@tekkare/romulus 0.1.53 → 0.1.55

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.16.0"
   },
-  "version": "0.1.52",
+  "version": "0.1.54",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/runtime/utils/filterOptions.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Les options d'un filtre a referentiel long, cherchees dans l'index.
+ *
+ * Un filtre agrege un champ (les marques, les molecules) et cherche sur
+ * d'autres. La regle qui compte est la : sur un index ou une ligne porte a la
+ * fois la marque, la molecule, la classe et le laboratoire, chercher dans un
+ * filtre doit interroger AUSSI les champs freres, sans changer ce que le
+ * filtre remonte. « keytruda » tape dans le filtre molecule trouve la ligne
+ * par sa marque et l'agregation en sort PEMBROLIZUMAB ; « pembrolizumab »
+ * tape dans le filtre marque en sort Keytruda. Sans cela l'utilisateur doit
+ * connaitre le nom qu'il cherche dans le vocabulaire exact du filtre, ce qui
+ * est justement ce qu'il vient demander.
+ *
+ * Le module ne parle pas au moteur : il ecrit le corps de la requete et relit
+ * les seaux. Le transport (proxy, cache, index) reste a l'application.
+ */
+export interface RmFilterOption {
+    label: string;
+    value: string;
+}
+export interface RmFilterOptionsSpec {
+    /**
+     * Ce que le filtre agrege. Un champ : la valeur est son propre libelle
+     * (`brand.keyword`). Deux champs `[libelle, valeur]` : le premier s'affiche,
+     * le second est ce que l'analyse filtre (un libelle ATC et son code).
+     */
+    field: string | [string, string];
+    /**
+     * Champs interroges par la saisie, dans l'ordre : le champ propre au filtre
+     * d'abord, ses synonymes ensuite. Champs analyses (`brand`), pas leur
+     * `.keyword` : un `.keyword` ne repond pas a une recherche partielle.
+     */
+    search: string[];
+    /** La saisie, telle qu'elle est tapee. Vide, tout le referentiel remonte. */
+    input: string;
+    /**
+     * Plafond de la liste. Au-dela, c'est la recherche qui trie : une liste
+     * coupee a cent laisse croire que ce qui suit n'existe pas.
+     */
+    size?: number;
+}
+/** Le corps de la requete d'agregation, a poster tel quel sur l'index. */
+export declare function rmFilterOptionsQuery(spec: RmFilterOptionsSpec): {
+    size: number;
+    query: {
+        bool: {
+            must: {
+                query_string: {
+                    fields: string[];
+                    query: string;
+                    analyze_wildcard: boolean;
+                    default_operator: string;
+                };
+            }[];
+        };
+    };
+    aggs: {
+        count: {
+            multi_terms: {
+                terms: {
+                    field: string;
+                }[];
+                size: number;
+                order: {
+                    _key: string;
+                };
+            };
+            terms?: undefined;
+        } | {
+            terms: {
+                field: string;
+                size: number;
+                order: {
+                    _key: string;
+                };
+            };
+            multi_terms?: undefined;
+        };
+    };
+};
+/** Les options, relues dans la reponse du moteur. */
+export declare function rmFilterOptions(response: any): RmFilterOption[];
+/** Un champ interroge par la saisie d'un filtre. */
+export interface RmFilterSearchField {
+    /** Champ interroge. La recherche porte sur son `.keyword`. */
+    field: string;
+    /**
+     * Chemins nested a traverser pour l'atteindre, du plus large au plus
+     * etroit (`['brand_history']`, ou `['a', 'a.b']` pour deux niveaux).
+     * Absent, le champ est a la racine du document.
+     */
+    nested?: string[];
+}
+/**
+ * La clause qui restreint les documents a la saisie, sur plusieurs champs a la
+ * fois. Meme regle que `rmFilterOptionsQuery`, pour un index ou le champ frere
+ * ne vit pas au meme niveau que le champ agrege : le filtre marque d'un index
+ * d'avis agrege `brand_group` a la racine et cherche la molecule dans
+ * `brand_history`, si bien que « pembro » sort KEYTRUDA. Un champ nested
+ * interroge sans son enveloppe `nested` ne repond jamais : c'est un filtre qui
+ * parait vide plutot qu'un filtre en erreur, d'ou cette enveloppe explicite.
+ *
+ * Trois facons de reconnaitre la saisie par champ : le fragment n'importe ou
+ * (`regexp`), la valeur entiere, et le debut. La derniere remonte en tete des
+ * listes ordonnees par pertinence.
+ */
+export declare function rmFilterSearchClause(fields: RmFilterSearchField[], input: string): {
+    bool: {
+        should: any[];
+    };
+};

package/dist/runtime/utils/filterOptions.js

@@ -0,0 +1,69 @@
+const DEFAULT_SIZE = 5e3;
+function wildcard(input) {
+  return ("*" + input + "*").normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+export function rmFilterOptionsQuery(spec) {
+  const size = spec.size ?? DEFAULT_SIZE;
+  const count = Array.isArray(spec.field) ? {
+    multi_terms: {
+      terms: spec.field.map((field) => ({ field })),
+      size,
+      order: { _key: "asc" }
+    }
+  } : { terms: { field: spec.field, size, order: { _key: "asc" } } };
+  return {
+    size: 0,
+    query: {
+      bool: {
+        must: [
+          {
+            query_string: {
+              // Plusieurs champs valent un OU : la ligne repond des qu'un seul
+              // d'entre eux porte la saisie. C'est ce qui rend les synonymes.
+              fields: spec.search,
+              query: wildcard(spec.input),
+              analyze_wildcard: true,
+              default_operator: "AND"
+            }
+          }
+        ]
+      }
+    },
+    aggs: { count }
+  };
+}
+export function rmFilterOptions(response) {
+  const buckets = response?.aggregations?.count?.buckets ?? [];
+  return buckets.map(
+    (bucket) => Array.isArray(bucket.key) ? { label: String(bucket.key[0]), value: String(bucket.key[1]) } : { label: String(bucket.key), value: String(bucket.key) }
+  );
+}
+export function rmFilterSearchClause(fields, input) {
+  return {
+    bool: {
+      should: fields.map(({ field, nested }) => {
+        const clause = {
+          bool: {
+            should: [
+              {
+                regexp: {
+                  [`${field}.keyword`]: {
+                    value: `.*${input}.*`,
+                    flags: "ALL",
+                    case_insensitive: true
+                  }
+                }
+              },
+              { match_phrase: { [`${field}.keyword`]: input } },
+              { prefix: { [`${field}.keyword`]: input } }
+            ]
+          }
+        };
+        return (nested ?? []).reduceRight(
+          (query, path) => ({ nested: { path, query } }),
+          clause
+        );
+      })
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",