@digigov/text-search 1.2.0-85c27c19 → 1.2.0-8bbad051

package/cjs/hook/index.js

@@ -32,19 +32,19 @@ __export(hook_exports, {
 });
 module.exports = __toCommonJS(hook_exports);
 var import_react = require("react");
-var import_search = __toESM(require("./search"));
+var import_search = __toESM(require("@digigov/text-search/search"));
 function useSearch(documents, query, options) {
   const [loading, setLoading] = (0, import_react.useState)(false);
   const [data, setData] = (0, import_react.useState)(documents);
   const indexing = options?.indexing;
-  const index = (0, import_react.useMemo)(() => new import_search.default(documents, indexing), [
-    documents,
-    indexing
-  ]);
+  const index = (0, import_react.useMemo)(
+    () => new import_search.default(documents, indexing),
+    [documents, indexing]
+  );
   const search = (0, import_react.useCallback)(() => {
     if (query) {
       setLoading(true);
-      index.searchAsync(documents, query).then((data2) => setData(data2)).finally(() => setLoading(false));
+      index.searchAsync(documents, query).then((data2) => setData(data2)).catch(() => setData([])).finally(() => setLoading(false));
     } else {
       setData(documents);
     }

package/cjs/hook.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/hook.ts"],
-  "sourcesContent": ["import { useCallback, useMemo, useState } from 'react';\nimport SearchIndex from './search';\nimport { UseSearchOptions } from './types';\n\n/**\n * Hook for searching through a list of documents\n *\n * Returns a list of documents that match the search query.\n * If no query is provided, it returns the original list of documents.\n *\n * @param documents - The list of documents to search through\n * @param options - Options for configuring the search index\n * @param query - The search query\n *\n * @typeParam T - The type of the data in the documents list\n */\nexport default function useSearch<T extends Record<string, any>>(\n  documents: T[],\n  query?: string,\n  options?: UseSearchOptions<T>\n) {\n  const [loading, setLoading] = useState(false);\n  const [data, setData] = useState(documents);\n\n  const indexing = options?.indexing;\n\n  const index = useMemo(() => new SearchIndex(documents, indexing), [\n    documents,\n    indexing,\n  ]);\n\n  const search = useCallback(() => {\n    if (query) {\n      setLoading(true);\n      index\n        .searchAsync(documents, query)\n        .then((data) => setData(data))\n        .finally(() => setLoading(false));\n    } else {\n      setData(documents);\n    }\n  }, [query, index, documents]);\n\n  const reset = useCallback(() => {\n    setData(documents);\n    setLoading(false);\n  }, [documents]);\n\n  return { data, loading, search, reset };\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA+C;AAC/C,oBAAwB;AAeT,SAAR,UACL,WACA,OACA,SACA;AACA,QAAM,CAAC,SAAS,UAAU,QAAI,uBAAS,KAAK;AAC5C,QAAM,CAAC,MAAM,OAAO,QAAI,uBAAS,SAAS;AAE1C,QAAM,WAAW,SAAS;AAE1B,QAAM,YAAQ,sBAAQ,MAAM,IAAI,cAAAA,QAAY,WAAW,QAAQ,GAAG;AAAA,IAChE;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,aAAS,0BAAY,MAAM;AAC/B,QAAI,OAAO;AACT,iBAAW,IAAI;AACf,YACG,YAAY,WAAW,KAAK,EAC5B,KAAK,CAACC,UAAS,QAAQA,KAAI,CAAC,EAC5B,QAAQ,MAAM,WAAW,KAAK,CAAC;AAAA,IACpC,OAAO;AACL,cAAQ,SAAS;AAAA,IACnB;AAAA,EACF,GAAG,CAAC,OAAO,OAAO,SAAS,CAAC;AAE5B,QAAM,YAAQ,0BAAY,MAAM;AAC9B,YAAQ,SAAS;AACjB,eAAW,KAAK;AAAA,EAClB,GAAG,CAAC,SAAS,CAAC;AAEd,SAAO,EAAE,MAAM,SAAS,QAAQ,MAAM;AACxC;",
+  "sourcesContent": ["import { useCallback, useMemo, useState } from 'react';\nimport SearchIndex from '@digigov/text-search/search';\nimport { UseSearchOptions } from '@digigov/text-search/types';\n\n/**\n * Hook for searching through a list of documents\n *\n * Returns a list of documents that match the search query.\n * If no query is provided, it returns the original list of documents.\n *\n * @param documents - The list of documents to search through\n * @param options - Options for configuring the search index\n * @param query - The search query\n *\n * @typeParam T - The type of the data in the documents list\n */\nexport default function useSearch<T extends Record<string, any>>(\n  documents: T[],\n  query?: string,\n  options?: UseSearchOptions<T>\n) {\n  const [loading, setLoading] = useState(false);\n  const [data, setData] = useState(documents);\n\n  const indexing = options?.indexing;\n\n  const index = useMemo(\n    () => new SearchIndex(documents, indexing),\n    [documents, indexing]\n  );\n\n  const search = useCallback(() => {\n    if (query) {\n      setLoading(true);\n      index\n        .searchAsync(documents, query)\n        .then((data) => setData(data))\n        .catch(() => setData([]))\n        .finally(() => setLoading(false));\n    } else {\n      setData(documents);\n    }\n  }, [query, index, documents]);\n\n  const reset = useCallback(() => {\n    setData(documents);\n    setLoading(false);\n  }, [documents]);\n\n  return { data, loading, search, reset };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA+C;AAC/C,oBAAwB;AAeT,SAAR,UACL,WACA,OACA,SACA;AACA,QAAM,CAAC,SAAS,UAAU,QAAI,uBAAS,KAAK;AAC5C,QAAM,CAAC,MAAM,OAAO,QAAI,uBAAS,SAAS;AAE1C,QAAM,WAAW,SAAS;AAE1B,QAAM,YAAQ;AAAA,IACZ,MAAM,IAAI,cAAAA,QAAY,WAAW,QAAQ;AAAA,IACzC,CAAC,WAAW,QAAQ;AAAA,EACtB;AAEA,QAAM,aAAS,0BAAY,MAAM;AAC/B,QAAI,OAAO;AACT,iBAAW,IAAI;AACf,YACG,YAAY,WAAW,KAAK,EAC5B,KAAK,CAACC,UAAS,QAAQA,KAAI,CAAC,EAC5B,MAAM,MAAM,QAAQ,CAAC,CAAC,CAAC,EACvB,QAAQ,MAAM,WAAW,KAAK,CAAC;AAAA,IACpC,OAAO;AACL,cAAQ,SAAS;AAAA,IACnB;AAAA,EACF,GAAG,CAAC,OAAO,OAAO,SAAS,CAAC;AAE5B,QAAM,YAAQ,0BAAY,MAAM;AAC9B,YAAQ,SAAS;AACjB,eAAW,KAAK;AAAA,EAClB,GAAG,CAAC,SAAS,CAAC;AAEd,SAAO,EAAE,MAAM,SAAS,QAAQ,MAAM;AACxC;",
   "names": ["SearchIndex", "data"]
 }

package/cjs/index.js

@@ -32,11 +32,11 @@ __export(src_exports, {
   default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-var import_hook = __toESM(require("./hook"));
-__reExport(src_exports, require("./search"), module.exports);
+var import_hook = __toESM(require("@digigov/text-search/hook"));
+__reExport(src_exports, require("@digigov/text-search/search"), module.exports);
 var src_default = import_hook.default;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./search")
+  ...require("@digigov/text-search/search")
 });
 //# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["import useSearch from './hook';\n\nexport default useSearch;\nexport * from './search';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAsB;AAGtB,wBAAc,qBAHd;AAEA,IAAO,cAAQ,YAAAA;",
+  "sourcesContent": ["import useSearch from '@digigov/text-search/hook';\n\nexport default useSearch;\nexport * from '@digigov/text-search/search';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAsB;AAGtB,wBAAc,wCAHd;AAEA,IAAO,cAAQ,YAAAA;",
   "names": ["useSearch"]
 }

package/cjs/search/index.js

@@ -21,6 +21,6 @@ __export(search_exports, {
   default: () => search_default
 });
 module.exports = __toCommonJS(search_exports);
-var import_search_index = require("./search-index");
+var import_search_index = require("@digigov/text-search/search/search-index");
 var search_default = import_search_index.SearchIndex;
 //# sourceMappingURL=index.js.map

package/cjs/search/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/search/index.ts"],
-  "sourcesContent": ["import { SearchIndex } from './search-index';\n\nexport default SearchIndex;\n"],
+  "sourcesContent": ["import { SearchIndex } from '@digigov/text-search/search/search-index';\n\nexport default SearchIndex;\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAA4B;AAE5B,IAAO,iBAAQ;",
   "names": []
 }

package/cjs/search/lang/gr/encoder/index.js

@@ -21,15 +21,18 @@ __export(encoder_exports, {
   encodeGreek: () => encodeGreek
 });
 module.exports = __toCommonJS(encoder_exports);
-var import_normalization_map = require("./normalization-map");
-const whitespaceRegex = /[\p{Z}\p{S}\p{P}\p{C}]+/u;
-const diacriticsRegex = /[\u0300-\u036f]/g;
+var import_normalization_map = require("@digigov/text-search/search/lang/gr/normalization-map");
+const whitespaceRegex = new RegExp("[p{Z}p{S}p{P}p{C}]+", "u");
+const diacriticsRegex = new RegExp("[\u0300-\u036F]", "g");
 const greekCharsRegex = new RegExp(
   Object.keys(import_normalization_map.greekToGreeklishMap).join("|"),
   "igu"
 );
 function encodeGreek(str) {
-  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(greekCharsRegex, (match) => import_normalization_map.greekToGreeklishMap[match]).split(whitespaceRegex);
+  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(
+    greekCharsRegex,
+    (match) => match in import_normalization_map.greekToGreeklishMap ? import_normalization_map.greekToGreeklishMap[match] : match
+  ).split(whitespaceRegex);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/cjs/search/lang/gr/encoder.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/search/lang/gr/encoder.ts"],
-  "sourcesContent": ["import { greekToGreeklishMap } from './normalization-map';\n\nconst whitespaceRegex = /[\\p{Z}\\p{S}\\p{P}\\p{C}]+/u;\nconst diacriticsRegex = /[\\u0300-\\u036f]/g;\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) => (greekToGreeklishMap as any)[match])\n    .split(whitespaceRegex);\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAAoC;AAEpC,MAAM,kBAAkB;AACxB,MAAM,kBAAkB;AACxB,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,4CAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B,QAAQ,iBAAiB,CAAC,UAAW,6CAA4B,KAAK,CAAC,EACvE,MAAM,eAAe;AAC1B;",
+  "sourcesContent": ["import { greekToGreeklishMap } from '@digigov/text-search/search/lang/gr/normalization-map';\n\nconst whitespaceRegex = new RegExp('[p{Z}p{S}p{P}p{C}]+', 'u');\nconst diacriticsRegex = new RegExp('[\\u0300-\\u036f]', 'g');\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) =>\n      match in greekToGreeklishMap\n        ? greekToGreeklishMap[match as keyof typeof greekToGreeklishMap]\n        : match\n    )\n    .split(whitespaceRegex);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAAoC;AAEpC,MAAM,kBAAkB,IAAI,OAAO,uBAAuB,GAAG;AAC7D,MAAM,kBAAkB,IAAI,OAAO,mBAAmB,GAAG;AACzD,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,4CAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B;AAAA,IAAQ;AAAA,IAAiB,CAAC,UACzB,SAAS,+CACL,6CAAoB,KAAyC,IAC7D;AAAA,EACN,EACC,MAAM,eAAe;AAC1B;",
   "names": []
 }

package/cjs/search/search-index/index.js

@@ -22,8 +22,8 @@ __export(search_index_exports, {
 });
 module.exports = __toCommonJS(search_index_exports);
 var import_flexsearch = require("flexsearch");
-var import_encoder = require("./lang/gr/encoder");
-var import_utils = require("./utils");
+var import_encoder = require("@digigov/text-search/search/lang/gr/encoder");
+var import_utils = require("@digigov/text-search/search/utils");
 class SearchIndex {
   constructor(items, options) {
     this.idKey = "id";

package/cjs/search/search-index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/search/search-index.ts"],
-  "sourcesContent": ["import { Document } from 'flexsearch';\nimport type { SearchIndexOptions } from '../types';\nimport { encodeGreek } from './lang/gr/encoder';\nimport { findItemsByIds, getAllItemKeys, getResultIds } from './utils';\n\n/**\n * Wrapper class around third party index and search library\n *\n * @typeParam T - The type of the data that will be indexed\n */\nexport class SearchIndex<T extends Record<string, any>> {\n  /**\n   * Instance of the third party library's index\n   */\n  private index: Document<T>;\n  private idKey: string;\n\n  constructor(items: T[], options?: SearchIndexOptions<T>) {\n    this.idKey = 'id';\n    if (options && options.idKey) {\n      this.idKey = options.idKey.replace('.', ':');\n    } else if (!(items[0] && 'id' in items[0])) {\n      items = items.map((item, index) => ({ ...item, id: index }));\n    }\n\n    let fields: string[] = [];\n    if (options && options.fields) {\n      fields = options.fields;\n    } else if (items[0]) {\n      fields = getAllItemKeys(items[0]);\n    }\n    fields = fields\n      .filter((field) => field !== this.idKey)\n      .map((field) => field.replace('.', ':'));\n\n    this.index = new Document<T>({\n      document: {\n        id: this.idKey,\n        index: fields,\n      },\n      tokenize: 'forward',\n      worker: options?.enableWorker,\n      encode: encodeGreek,\n    });\n\n    this.addAll(items);\n  }\n\n  /**\n   * Add an item to the index\n   *\n   * @param item - The item to add to the index\n   */\n  public add(item: T) {\n    this.index.add(item);\n    return this;\n  }\n\n  /**\n   * Add multiple items to the index\n   *\n   * @param items - The list of items to add to the index\n   */\n  public addAll(items: T[]) {\n    items.forEach((item) => this.index.add(item));\n    return this;\n  }\n\n  /**\n   * Search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public search(documents: T[], searchTerm: string) {\n    const res = this.index.search(searchTerm);\n    const ids = getResultIds(res);\n    return findItemsByIds(\n      documents,\n      ids,\n      this.idKey as Extract<keyof T, string>\n    );\n  }\n\n  /**\n   * Asynchronously search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public async searchAsync(documents: T[], searchTerm: string) {\n    return this.index\n      .searchAsync(searchTerm)\n      .then((res) => {\n        return getResultIds(res);\n      })\n      .then((res) =>\n        findItemsByIds(documents, res, this.idKey as Extract<keyof T, string>)\n      );\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAyB;AAEzB,qBAA4B;AAC5B,mBAA6D;AAOtD,MAAM,YAA2C;AAAA,EAOtD,YAAY,OAAY,SAAiC;AACvD,SAAK,QAAQ;AACb,QAAI,WAAW,QAAQ,OAAO;AAC5B,WAAK,QAAQ,QAAQ,MAAM,QAAQ,KAAK,GAAG;AAAA,IAC7C,WAAW,EAAE,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,IAAI;AAC1C,cAAQ,MAAM,IAAI,CAAC,MAAM,WAAW,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE;AAAA,IAC7D;AAEA,QAAI,SAAmB,CAAC;AACxB,QAAI,WAAW,QAAQ,QAAQ;AAC7B,eAAS,QAAQ;AAAA,IACnB,WAAW,MAAM,CAAC,GAAG;AACnB,mBAAS,6BAAe,MAAM,CAAC,CAAC;AAAA,IAClC;AACA,aAAS,OACN,OAAO,CAAC,UAAU,UAAU,KAAK,KAAK,EACtC,IAAI,CAAC,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;AAEzC,SAAK,QAAQ,IAAI,2BAAY;AAAA,MAC3B,UAAU;AAAA,QACR,IAAI,KAAK;AAAA,QACT,OAAO;AAAA,MACT;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,SAAS;AAAA,MACjB,QAAQ;AAAA,IACV,CAAC;AAED,SAAK,OAAO,KAAK;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IAAI,MAAS;AAClB,SAAK,MAAM,IAAI,IAAI;AACnB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,OAAO,OAAY;AACxB,UAAM,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,IAAI,CAAC;AAC5C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,OAAO,WAAgB,YAAoB;AAChD,UAAM,MAAM,KAAK,MAAM,OAAO,UAAU;AACxC,UAAM,UAAM,2BAAa,GAAG;AAC5B,eAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,YAAY,WAAgB,YAAoB;AAC3D,WAAO,KAAK,MACT,YAAY,UAAU,EACtB,KAAK,CAAC,QAAQ;AACb,iBAAO,2BAAa,GAAG;AAAA,IACzB,CAAC,EACA;AAAA,MAAK,CAAC,YACL,6BAAe,WAAW,KAAK,KAAK,KAAiC;AAAA,IACvE;AAAA,EACJ;AACF;",
+  "sourcesContent": ["import { Document } from 'flexsearch';\nimport { encodeGreek } from '@digigov/text-search/search/lang/gr/encoder';\nimport {\n  findItemsByIds,\n  getAllItemKeys,\n  getResultIds,\n} from '@digigov/text-search/search/utils';\nimport type { SearchIndexOptions } from '@digigov/text-search/types';\n\n/**\n * Wrapper class around third party index and search library\n *\n * @typeParam T - The type of the data that will be indexed\n */\nexport class SearchIndex<T extends Record<string, any>> {\n  /**\n   * Instance of the third party library's index\n   */\n  private index: Document<T>;\n  private idKey: string;\n\n  constructor(items: T[], options?: SearchIndexOptions<T>) {\n    this.idKey = 'id';\n    if (options && options.idKey) {\n      this.idKey = options.idKey.replace('.', ':');\n    } else if (!(items[0] && 'id' in items[0])) {\n      items = items.map((item, index) => ({ ...item, id: index }));\n    }\n\n    let fields: string[] = [];\n    if (options && options.fields) {\n      fields = options.fields;\n    } else if (items[0]) {\n      fields = getAllItemKeys(items[0]);\n    }\n    fields = fields\n      .filter((field) => field !== this.idKey)\n      .map((field) => field.replace('.', ':'));\n\n    this.index = new Document<T>({\n      document: {\n        id: this.idKey,\n        index: fields,\n      },\n      tokenize: 'forward',\n      worker: options?.enableWorker,\n      encode: encodeGreek,\n    });\n\n    this.addAll(items);\n  }\n\n  /**\n   * Add an item to the index\n   *\n   * @param item - The item to add to the index\n   */\n  public add(item: T) {\n    this.index.add(item);\n    return this;\n  }\n\n  /**\n   * Add multiple items to the index\n   *\n   * @param items - The list of items to add to the index\n   */\n  public addAll(items: T[]) {\n    items.forEach((item) => this.index.add(item));\n    return this;\n  }\n\n  /**\n   * Search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public search(documents: T[], searchTerm: string) {\n    const res = this.index.search(searchTerm);\n    const ids = getResultIds(res);\n    return findItemsByIds(\n      documents,\n      ids,\n      this.idKey as Extract<keyof T, string>\n    );\n  }\n\n  /**\n   * Asynchronously search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public async searchAsync(documents: T[], searchTerm: string) {\n    return this.index\n      .searchAsync(searchTerm)\n      .then((res) => {\n        return getResultIds(res);\n      })\n      .then((res) =>\n        findItemsByIds(documents, res, this.idKey as Extract<keyof T, string>)\n      );\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAyB;AACzB,qBAA4B;AAC5B,mBAIO;AAQA,MAAM,YAA2C;AAAA,EAOtD,YAAY,OAAY,SAAiC;AACvD,SAAK,QAAQ;AACb,QAAI,WAAW,QAAQ,OAAO;AAC5B,WAAK,QAAQ,QAAQ,MAAM,QAAQ,KAAK,GAAG;AAAA,IAC7C,WAAW,EAAE,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,IAAI;AAC1C,cAAQ,MAAM,IAAI,CAAC,MAAM,WAAW,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE;AAAA,IAC7D;AAEA,QAAI,SAAmB,CAAC;AACxB,QAAI,WAAW,QAAQ,QAAQ;AAC7B,eAAS,QAAQ;AAAA,IACnB,WAAW,MAAM,CAAC,GAAG;AACnB,mBAAS,6BAAe,MAAM,CAAC,CAAC;AAAA,IAClC;AACA,aAAS,OACN,OAAO,CAAC,UAAU,UAAU,KAAK,KAAK,EACtC,IAAI,CAAC,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;AAEzC,SAAK,QAAQ,IAAI,2BAAY;AAAA,MAC3B,UAAU;AAAA,QACR,IAAI,KAAK;AAAA,QACT,OAAO;AAAA,MACT;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,SAAS;AAAA,MACjB,QAAQ;AAAA,IACV,CAAC;AAED,SAAK,OAAO,KAAK;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IAAI,MAAS;AAClB,SAAK,MAAM,IAAI,IAAI;AACnB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,OAAO,OAAY;AACxB,UAAM,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,IAAI,CAAC;AAC5C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,OAAO,WAAgB,YAAoB;AAChD,UAAM,MAAM,KAAK,MAAM,OAAO,UAAU;AACxC,UAAM,UAAM,2BAAa,GAAG;AAC5B,eAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,YAAY,WAAgB,YAAoB;AAC3D,WAAO,KAAK,MACT,YAAY,UAAU,EACtB,KAAK,CAAC,QAAQ;AACb,iBAAO,2BAAa,GAAG;AAAA,IACzB,CAAC,EACA;AAAA,MAAK,CAAC,YACL,6BAAe,WAAW,KAAK,KAAK,KAAiC;AAAA,IACvE;AAAA,EACJ;AACF;",
   "names": []
 }

package/cjs/search/utils/index.js

@@ -39,7 +39,7 @@ function getValueFromNestedKey(object, nestedKey) {
   const keys = nestedKey.split(":");
   let result = object;
   for (const keySegment of keys) {
-    if (result.hasOwnProperty(keySegment)) {
+    if (Object.prototype.hasOwnProperty.call(result, keySegment)) {
       result = result[keySegment];
     }
   }
@@ -48,7 +48,7 @@ function getValueFromNestedKey(object, nestedKey) {
 function getAllItemKeys(object, parentKey = "") {
   let keys = [];
   for (const key in object) {
-    if (object.hasOwnProperty(key)) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
       const currentKey = parentKey ? `${parentKey}.${key}` : key;
       if (typeof object[key] === "object" && object[key] !== null) {
         keys = keys.concat(getAllItemKeys(object[key], currentKey));

package/cjs/search/utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/search/utils.ts"],
-  "sourcesContent": ["import { SimpleDocumentSearchResultSetUnit } from 'flexsearch';\n\n/**\n * Extracts the unique item IDs from the result set\n *\n * @param result - The result set to extract the IDs from\n */\nexport function getResultIds(result: SimpleDocumentSearchResultSetUnit[]) {\n  const set = new Set<number | string>();\n  result.forEach((item) => {\n    item.result.forEach((id) => set.add(id));\n  });\n  return Array.from(set);\n}\n\n/**\n * Get the items from the list that match the given IDs\n *\n * @param items - The list of items to search through\n * @param ids - The list of IDs to search for\n * @param idKey - The key to use to find the IDs in the items\n */\nexport function findItemsByIds<T extends Record<string, any>>(\n  items: T[],\n  ids: (string | number)[],\n  idKey: Extract<keyof T, string>\n) {\n  return items.filter(\n    (item) => item && ids.includes(getValueFromNestedKey(item, idKey))\n  );\n}\n\nfunction getValueFromNestedKey(object: Record<string, any>, nestedKey: string) {\n  const keys = nestedKey.split(':');\n\n  let result = object;\n  for (const keySegment of keys) {\n    if (result.hasOwnProperty(keySegment)) {\n      result = result[keySegment];\n    }\n  }\n  return (result as unknown) as string;\n}\n\n/**\n * Recursively get all the keys from an object\n *\n * The keys are returned in the format `parentKey.childKey` for nested objects\n * and `key` for top level objects (objects that are not nested inside another object).\n *\n * @param object - The item to get the keys from\n * @param parentKey - The parent key to which the current key should be appended\n */\nexport function getAllItemKeys(\n  object: Record<string, any>,\n  parentKey: string = ''\n): string[] {\n  let keys: string[] = [];\n  for (const key in object) {\n    if (object.hasOwnProperty(key)) {\n      const currentKey = parentKey ? `${parentKey}.${key}` : key;\n\n      if (typeof object[key] === 'object' && object[key] !== null) {\n        keys = keys.concat(getAllItemKeys(object[key], currentKey));\n      } else {\n        keys.push(currentKey);\n      }\n    }\n  }\n\n  return keys;\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,SAAS,aAAa,QAA6C;AACxE,QAAM,MAAM,oBAAI,IAAqB;AACrC,SAAO,QAAQ,CAAC,SAAS;AACvB,SAAK,OAAO,QAAQ,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;AAAA,EACzC,CAAC;AACD,SAAO,MAAM,KAAK,GAAG;AACvB;AASO,SAAS,eACd,OACA,KACA,OACA;AACA,SAAO,MAAM;AAAA,IACX,CAAC,SAAS,QAAQ,IAAI,SAAS,sBAAsB,MAAM,KAAK,CAAC;AAAA,EACnE;AACF;AAEA,SAAS,sBAAsB,QAA6B,WAAmB;AAC7E,QAAM,OAAO,UAAU,MAAM,GAAG;AAEhC,MAAI,SAAS;AACb,aAAW,cAAc,MAAM;AAC7B,QAAI,OAAO,eAAe,UAAU,GAAG;AACrC,eAAS,OAAO,UAAU;AAAA,IAC5B;AAAA,EACF;AACA,SAAQ;AACV;AAWO,SAAS,eACd,QACA,YAAoB,IACV;AACV,MAAI,OAAiB,CAAC;AACtB,aAAW,OAAO,QAAQ;AACxB,QAAI,OAAO,eAAe,GAAG,GAAG;AAC9B,YAAM,aAAa,YAAY,GAAG,SAAS,IAAI,GAAG,KAAK;AAEvD,UAAI,OAAO,OAAO,GAAG,MAAM,YAAY,OAAO,GAAG,MAAM,MAAM;AAC3D,eAAO,KAAK,OAAO,eAAe,OAAO,GAAG,GAAG,UAAU,CAAC;AAAA,MAC5D,OAAO;AACL,aAAK,KAAK,UAAU;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
+  "sourcesContent": ["import { SimpleDocumentSearchResultSetUnit } from 'flexsearch';\n\n/**\n * Extracts the unique item IDs from the result set\n *\n * @param result - The result set to extract the IDs from\n */\nexport function getResultIds(result: SimpleDocumentSearchResultSetUnit[]) {\n  const set = new Set<number | string>();\n  result.forEach((item) => {\n    item.result.forEach((id) => set.add(id));\n  });\n  return Array.from(set);\n}\n\n/**\n * Get the items from the list that match the given IDs\n *\n * @param items - The list of items to search through\n * @param ids - The list of IDs to search for\n * @param idKey - The key to use to find the IDs in the items\n */\nexport function findItemsByIds<T extends Record<string, any>>(\n  items: T[],\n  ids: (string | number)[],\n  idKey: Extract<keyof T, string>\n) {\n  return items.filter(\n    (item) => item && ids.includes(getValueFromNestedKey(item, idKey))\n  );\n}\n\nfunction getValueFromNestedKey(object: Record<string, any>, nestedKey: string) {\n  const keys = nestedKey.split(':');\n\n  let result = object;\n  for (const keySegment of keys) {\n    if (Object.prototype.hasOwnProperty.call(result, keySegment)) {\n      result = result[keySegment];\n    }\n  }\n  return result as unknown as string;\n}\n\n/**\n * Recursively get all the keys from an object\n *\n * The keys are returned in the format `parentKey.childKey` for nested objects\n * and `key` for top level objects (objects that are not nested inside another object).\n *\n * @param object - The item to get the keys from\n * @param parentKey - The parent key to which the current key should be appended\n */\nexport function getAllItemKeys(\n  object: Record<string, any>,\n  parentKey = ''\n): string[] {\n  let keys: string[] = [];\n  for (const key in object) {\n    if (Object.prototype.hasOwnProperty.call(object, key)) {\n      const currentKey = parentKey ? `${parentKey}.${key}` : key;\n\n      if (typeof object[key] === 'object' && object[key] !== null) {\n        keys = keys.concat(getAllItemKeys(object[key], currentKey));\n      } else {\n        keys.push(currentKey);\n      }\n    }\n  }\n\n  return keys;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOO,SAAS,aAAa,QAA6C;AACxE,QAAM,MAAM,oBAAI,IAAqB;AACrC,SAAO,QAAQ,CAAC,SAAS;AACvB,SAAK,OAAO,QAAQ,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;AAAA,EACzC,CAAC;AACD,SAAO,MAAM,KAAK,GAAG;AACvB;AASO,SAAS,eACd,OACA,KACA,OACA;AACA,SAAO,MAAM;AAAA,IACX,CAAC,SAAS,QAAQ,IAAI,SAAS,sBAAsB,MAAM,KAAK,CAAC;AAAA,EACnE;AACF;AAEA,SAAS,sBAAsB,QAA6B,WAAmB;AAC7E,QAAM,OAAO,UAAU,MAAM,GAAG;AAEhC,MAAI,SAAS;AACb,aAAW,cAAc,MAAM;AAC7B,QAAI,OAAO,UAAU,eAAe,KAAK,QAAQ,UAAU,GAAG;AAC5D,eAAS,OAAO,UAAU;AAAA,IAC5B;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,eACd,QACA,YAAY,IACF;AACV,MAAI,OAAiB,CAAC;AACtB,aAAW,OAAO,QAAQ;AACxB,QAAI,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,GAAG;AACrD,YAAM,aAAa,YAAY,GAAG,SAAS,IAAI,GAAG,KAAK;AAEvD,UAAI,OAAO,OAAO,GAAG,MAAM,YAAY,OAAO,GAAG,MAAM,MAAM;AAC3D,eAAO,KAAK,OAAO,eAAe,OAAO,GAAG,GAAG,UAAU,CAAC;AAAA,MAC5D,OAAO;AACL,aAAK,KAAK,UAAU;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
   "names": []
 }

package/cjs/types.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/types.ts"],
-  "sourcesContent": ["/**\n * Options for configuring the useSearch hook\n */\nexport interface UseSearchOptions<T extends Record<string, any>> {\n  indexing: SearchIndexOptions<T>;\n}\n\n/**\n * Options for configuring the search index\n *\n * @typeParam T - The type of the data that will be indexed\n */\nexport interface SearchIndexOptions<T> {\n  /**\n   * Describes where to find the unique ID for each item in the data\n   *\n   * This can also be a nested key, e.g. `address.street`. If not specified, the search index will\n   * create an 'id' field on each item, with the value being the index of the item in the array.\n   */\n  idKey?: NestedKeyOf<T>;\n  /**\n   * List of fields to index\n   *\n   * Contains a list of fields from the document, that should be indexed. The fields can be nested.\n   *\n   * @example Using nested keys\n   * ```\n   * {\n   *   id: 1,\n   *   name: 'John',\n   *   address: {\n   *     street: '123 Main St',\n   *     city: 'New York'\n   *   }\n   * }\n   * ```\n   * To search against the `street` key, add `address.street` to the fields array.\n   */\n  fields?: NestedKeyOf<T>[];\n  /**\n   * Whether to use a web worker for indexing\n   */\n  enableWorker?: boolean;\n}\n\n/**\n * Any key of an object that has nested objects.\n *\n * This utility type is used to get all the primitive keys of an object, including the keys of any nested objects.\n *\n * @typeParam ObjectType - The type of the object to get the keys of\n */\nexport type NestedKeyOf<T> = T extends Primitive\n  ? never\n  :\n      | (keyof T & string)\n      | { [P in keyof T & string]: DeepSubKeys<T, P> }[keyof T & string];\n\ntype DeepSubKeys<T, P extends keyof T & string> = T[P] extends (infer Inner)[]\n  ? `${P}.${NestedKeyOf<Inner>}`\n  : T[P] extends object\n  ? `${P}.${NestedKeyOf<T[P]>}`\n  : never;\n\ntype Primitive = null | undefined | string | number | boolean | symbol | bigint;\n"],
+  "sourcesContent": ["/**\n * Options for configuring the useSearch hook\n */\nexport interface UseSearchOptions<T extends Record<string, any>> {\n  indexing: SearchIndexOptions<T>;\n}\n\n/**\n * Options for configuring the search index\n *\n * @typeParam T - The type of the data that will be indexed\n */\nexport interface SearchIndexOptions<T> {\n  /**\n   * Describes where to find the unique ID for each item in the data\n   *\n   * This can also be a nested key, e.g. `address.street`. If not specified, the search index will\n   * create an 'id' field on each item, with the value being the index of the item in the array.\n   */\n  idKey?: NestedKeyOf<T>;\n  /**\n   * List of fields to index\n   *\n   * Contains a list of fields from the document, that should be indexed. The fields can be nested.\n   *\n   * @example Using nested keys\n   * ```\n   * {\n   *   id: 1,\n   *   name: 'John',\n   *   address: {\n   *     street: '123 Main St',\n   *     city: 'New York'\n   *   }\n   * }\n   * ```\n   * To search against the `street` key, add `address.street` to the fields array.\n   */\n  fields?: NestedKeyOf<T>[];\n  /**\n   * Whether to use a web worker for indexing\n   */\n  enableWorker?: boolean;\n}\n\n/**\n * Any key of an object that has nested objects.\n *\n * This utility type is used to get all the primitive keys of an object, including the keys of any nested objects.\n *\n * @typeParam ObjectType - The type of the object to get the keys of\n */\nexport type NestedKeyOf<T> = T extends Primitive\n  ? never\n  :\n      | (keyof T & string)\n      | { [P in keyof T & string]: DeepSubKeys<T, P> }[keyof T & string];\n\ntype DeepSubKeys<T, P extends keyof T & string> = T[P] extends (infer Inner)[]\n  ? `${P}.${NestedKeyOf<Inner>}`\n  : T[P] extends object\n    ? `${P}.${NestedKeyOf<T[P]>}`\n    : never;\n\ntype Primitive = null | undefined | string | number | boolean | symbol | bigint;\n"],
   "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
   "names": []
 }

package/hook/index.js

@@ -1,17 +1,17 @@
 import { useCallback, useMemo, useState } from "react";
-import SearchIndex from "./search";
+import SearchIndex from "@digigov/text-search/search";
 function useSearch(documents, query, options) {
   const [loading, setLoading] = useState(false);
   const [data, setData] = useState(documents);
   const indexing = options?.indexing;
-  const index = useMemo(() => new SearchIndex(documents, indexing), [
-    documents,
-    indexing
-  ]);
+  const index = useMemo(
+    () => new SearchIndex(documents, indexing),
+    [documents, indexing]
+  );
   const search = useCallback(() => {
     if (query) {
       setLoading(true);
-      index.searchAsync(documents, query).then((data2) => setData(data2)).finally(() => setLoading(false));
+      index.searchAsync(documents, query).then((data2) => setData(data2)).catch(() => setData([])).finally(() => setLoading(false));
     } else {
       setData(documents);
     }

package/hook.d.ts

@@ -1,4 +1,4 @@
-import { UseSearchOptions } from './types';
+import { UseSearchOptions } from '@digigov/text-search/types';
 /**
  * Hook for searching through a list of documents
  *

package/hook.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/hook.ts"],
-  "sourcesContent": ["import { useCallback, useMemo, useState } from 'react';\nimport SearchIndex from './search';\nimport { UseSearchOptions } from './types';\n\n/**\n * Hook for searching through a list of documents\n *\n * Returns a list of documents that match the search query.\n * If no query is provided, it returns the original list of documents.\n *\n * @param documents - The list of documents to search through\n * @param options - Options for configuring the search index\n * @param query - The search query\n *\n * @typeParam T - The type of the data in the documents list\n */\nexport default function useSearch<T extends Record<string, any>>(\n  documents: T[],\n  query?: string,\n  options?: UseSearchOptions<T>\n) {\n  const [loading, setLoading] = useState(false);\n  const [data, setData] = useState(documents);\n\n  const indexing = options?.indexing;\n\n  const index = useMemo(() => new SearchIndex(documents, indexing), [\n    documents,\n    indexing,\n  ]);\n\n  const search = useCallback(() => {\n    if (query) {\n      setLoading(true);\n      index\n        .searchAsync(documents, query)\n        .then((data) => setData(data))\n        .finally(() => setLoading(false));\n    } else {\n      setData(documents);\n    }\n  }, [query, index, documents]);\n\n  const reset = useCallback(() => {\n    setData(documents);\n    setLoading(false);\n  }, [documents]);\n\n  return { data, loading, search, reset };\n}\n"],
-  "mappings": "AAAA,SAAS,aAAa,SAAS,gBAAgB;AAC/C,OAAO,iBAAiB;AAeT,SAAR,UACL,WACA,OACA,SACA;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,KAAK;AAC5C,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,SAAS;AAE1C,QAAM,WAAW,SAAS;AAE1B,QAAM,QAAQ,QAAQ,MAAM,IAAI,YAAY,WAAW,QAAQ,GAAG;AAAA,IAChE;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,OAAO;AACT,iBAAW,IAAI;AACf,YACG,YAAY,WAAW,KAAK,EAC5B,KAAK,CAACA,UAAS,QAAQA,KAAI,CAAC,EAC5B,QAAQ,MAAM,WAAW,KAAK,CAAC;AAAA,IACpC,OAAO;AACL,cAAQ,SAAS;AAAA,IACnB;AAAA,EACF,GAAG,CAAC,OAAO,OAAO,SAAS,CAAC;AAE5B,QAAM,QAAQ,YAAY,MAAM;AAC9B,YAAQ,SAAS;AACjB,eAAW,KAAK;AAAA,EAClB,GAAG,CAAC,SAAS,CAAC;AAEd,SAAO,EAAE,MAAM,SAAS,QAAQ,MAAM;AACxC;",
+  "sourcesContent": ["import { useCallback, useMemo, useState } from 'react';\nimport SearchIndex from '@digigov/text-search/search';\nimport { UseSearchOptions } from '@digigov/text-search/types';\n\n/**\n * Hook for searching through a list of documents\n *\n * Returns a list of documents that match the search query.\n * If no query is provided, it returns the original list of documents.\n *\n * @param documents - The list of documents to search through\n * @param options - Options for configuring the search index\n * @param query - The search query\n *\n * @typeParam T - The type of the data in the documents list\n */\nexport default function useSearch<T extends Record<string, any>>(\n  documents: T[],\n  query?: string,\n  options?: UseSearchOptions<T>\n) {\n  const [loading, setLoading] = useState(false);\n  const [data, setData] = useState(documents);\n\n  const indexing = options?.indexing;\n\n  const index = useMemo(\n    () => new SearchIndex(documents, indexing),\n    [documents, indexing]\n  );\n\n  const search = useCallback(() => {\n    if (query) {\n      setLoading(true);\n      index\n        .searchAsync(documents, query)\n        .then((data) => setData(data))\n        .catch(() => setData([]))\n        .finally(() => setLoading(false));\n    } else {\n      setData(documents);\n    }\n  }, [query, index, documents]);\n\n  const reset = useCallback(() => {\n    setData(documents);\n    setLoading(false);\n  }, [documents]);\n\n  return { data, loading, search, reset };\n}\n"],
+  "mappings": "AAAA,SAAS,aAAa,SAAS,gBAAgB;AAC/C,OAAO,iBAAiB;AAeT,SAAR,UACL,WACA,OACA,SACA;AACA,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,KAAK;AAC5C,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,SAAS;AAE1C,QAAM,WAAW,SAAS;AAE1B,QAAM,QAAQ;AAAA,IACZ,MAAM,IAAI,YAAY,WAAW,QAAQ;AAAA,IACzC,CAAC,WAAW,QAAQ;AAAA,EACtB;AAEA,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,OAAO;AACT,iBAAW,IAAI;AACf,YACG,YAAY,WAAW,KAAK,EAC5B,KAAK,CAACA,UAAS,QAAQA,KAAI,CAAC,EAC5B,MAAM,MAAM,QAAQ,CAAC,CAAC,CAAC,EACvB,QAAQ,MAAM,WAAW,KAAK,CAAC;AAAA,IACpC,OAAO;AACL,cAAQ,SAAS;AAAA,IACnB;AAAA,EACF,GAAG,CAAC,OAAO,OAAO,SAAS,CAAC;AAE5B,QAAM,QAAQ,YAAY,MAAM;AAC9B,YAAQ,SAAS;AACjB,eAAW,KAAK;AAAA,EAClB,GAAG,CAAC,SAAS,CAAC;AAEd,SAAO,EAAE,MAAM,SAAS,QAAQ,MAAM;AACxC;",
   "names": ["data"]
 }

package/index.d.ts

@@ -1,3 +1,3 @@
-import useSearch from './hook';
+import useSearch from '@digigov/text-search/hook';
 export default useSearch;
-export * from './search';
+export * from '@digigov/text-search/search';

package/index.js

@@ -1,11 +1,11 @@
-/** @license Digigov v1.2.0-85c27c19
+/** @license Digigov v1.2.0-8bbad051
  *
  * This source code is licensed under the BSD-2-Clause license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import useSearch from "./hook";
+import useSearch from "@digigov/text-search/hook";
 var src_default = useSearch;
-export * from "./search";
+export * from "@digigov/text-search/search";
 export {
   src_default as default
 };

package/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["import useSearch from './hook';\n\nexport default useSearch;\nexport * from './search';\n"],
+  "sourcesContent": ["import useSearch from '@digigov/text-search/hook';\n\nexport default useSearch;\nexport * from '@digigov/text-search/search';\n"],
   "mappings": "AAAA,OAAO,eAAe;AAEtB,IAAO,cAAQ;AACf,cAAc;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digigov/text-search",
-  "version": "1.2.0-85c27c19",
+  "version": "1.2.0-8bbad051",
   "description": "@digigov text-search",
   "author": "GRNET Developers <devs@lists.grnet.gr>",
   "license": "BSD-2-Clause",
@@ -14,8 +14,8 @@
     "flexsearch": "0.7.31"
   },
   "peerDependencies": {
-    "react": ">=16.8.0 <19.0.0",
-    "react-dom": ">=16.8.0 <19.0.0"
+    "react": "^18.3.0 || ^19.1.0",
+    "react-dom": "^18.3.0 || ^19.1.0"
   },
   "typings": "./index.d.ts"
 }

package/search/index.d.ts

@@ -1,2 +1,2 @@
-import { SearchIndex } from './search-index';
+import { SearchIndex } from '@digigov/text-search/search/search-index';
 export default SearchIndex;

package/search/index.js

@@ -1,4 +1,4 @@
-import { SearchIndex } from "./search-index";
+import { SearchIndex } from "@digigov/text-search/search/search-index";
 var search_default = SearchIndex;
 export {
   search_default as default

package/search/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/search/index.ts"],
-  "sourcesContent": ["import { SearchIndex } from './search-index';\n\nexport default SearchIndex;\n"],
+  "sourcesContent": ["import { SearchIndex } from '@digigov/text-search/search/search-index';\n\nexport default SearchIndex;\n"],
   "mappings": "AAAA,SAAS,mBAAmB;AAE5B,IAAO,iBAAQ;",
   "names": []
 }

package/search/lang/gr/encoder/index.js

@@ -1,12 +1,15 @@
-import { greekToGreeklishMap } from "./normalization-map";
-const whitespaceRegex = /[\p{Z}\p{S}\p{P}\p{C}]+/u;
-const diacriticsRegex = /[\u0300-\u036f]/g;
+import { greekToGreeklishMap } from "@digigov/text-search/search/lang/gr/normalization-map";
+const whitespaceRegex = new RegExp("[p{Z}p{S}p{P}p{C}]+", "u");
+const diacriticsRegex = new RegExp("[\u0300-\u036F]", "g");
 const greekCharsRegex = new RegExp(
   Object.keys(greekToGreeklishMap).join("|"),
   "igu"
 );
 function encodeGreek(str) {
-  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(greekCharsRegex, (match) => greekToGreeklishMap[match]).split(whitespaceRegex);
+  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(
+    greekCharsRegex,
+    (match) => match in greekToGreeklishMap ? greekToGreeklishMap[match] : match
+  ).split(whitespaceRegex);
 }
 export {
   encodeGreek

package/search/lang/gr/encoder.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/search/lang/gr/encoder.ts"],
-  "sourcesContent": ["import { greekToGreeklishMap } from './normalization-map';\n\nconst whitespaceRegex = /[\\p{Z}\\p{S}\\p{P}\\p{C}]+/u;\nconst diacriticsRegex = /[\\u0300-\\u036f]/g;\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) => (greekToGreeklishMap as any)[match])\n    .split(whitespaceRegex);\n}\n"],
-  "mappings": "AAAA,SAAS,2BAA2B;AAEpC,MAAM,kBAAkB;AACxB,MAAM,kBAAkB;AACxB,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,mBAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B,QAAQ,iBAAiB,CAAC,UAAW,oBAA4B,KAAK,CAAC,EACvE,MAAM,eAAe;AAC1B;",
+  "sourcesContent": ["import { greekToGreeklishMap } from '@digigov/text-search/search/lang/gr/normalization-map';\n\nconst whitespaceRegex = new RegExp('[p{Z}p{S}p{P}p{C}]+', 'u');\nconst diacriticsRegex = new RegExp('[\\u0300-\\u036f]', 'g');\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) =>\n      match in greekToGreeklishMap\n        ? greekToGreeklishMap[match as keyof typeof greekToGreeklishMap]\n        : match\n    )\n    .split(whitespaceRegex);\n}\n"],
+  "mappings": "AAAA,SAAS,2BAA2B;AAEpC,MAAM,kBAAkB,IAAI,OAAO,uBAAuB,GAAG;AAC7D,MAAM,kBAAkB,IAAI,OAAO,mBAAmB,GAAG;AACzD,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,mBAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B;AAAA,IAAQ;AAAA,IAAiB,CAAC,UACzB,SAAS,sBACL,oBAAoB,KAAyC,IAC7D;AAAA,EACN,EACC,MAAM,eAAe;AAC1B;",
   "names": []
 }

package/search/search-index/index.js

@@ -1,6 +1,10 @@
 import { Document } from "flexsearch";
-import { encodeGreek } from "./lang/gr/encoder";
-import { findItemsByIds, getAllItemKeys, getResultIds } from "./utils";
+import { encodeGreek } from "@digigov/text-search/search/lang/gr/encoder";
+import {
+  findItemsByIds,
+  getAllItemKeys,
+  getResultIds
+} from "@digigov/text-search/search/utils";
 class SearchIndex {
   constructor(items, options) {
     this.idKey = "id";

package/search/search-index.d.ts

@@ -1,4 +1,4 @@
-import type { SearchIndexOptions } from '../types';
+import type { SearchIndexOptions } from '@digigov/text-search/types';
 /**
  * Wrapper class around third party index and search library
  *

package/search/search-index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/search/search-index.ts"],
-  "sourcesContent": ["import { Document } from 'flexsearch';\nimport type { SearchIndexOptions } from '../types';\nimport { encodeGreek } from './lang/gr/encoder';\nimport { findItemsByIds, getAllItemKeys, getResultIds } from './utils';\n\n/**\n * Wrapper class around third party index and search library\n *\n * @typeParam T - The type of the data that will be indexed\n */\nexport class SearchIndex<T extends Record<string, any>> {\n  /**\n   * Instance of the third party library's index\n   */\n  private index: Document<T>;\n  private idKey: string;\n\n  constructor(items: T[], options?: SearchIndexOptions<T>) {\n    this.idKey = 'id';\n    if (options && options.idKey) {\n      this.idKey = options.idKey.replace('.', ':');\n    } else if (!(items[0] && 'id' in items[0])) {\n      items = items.map((item, index) => ({ ...item, id: index }));\n    }\n\n    let fields: string[] = [];\n    if (options && options.fields) {\n      fields = options.fields;\n    } else if (items[0]) {\n      fields = getAllItemKeys(items[0]);\n    }\n    fields = fields\n      .filter((field) => field !== this.idKey)\n      .map((field) => field.replace('.', ':'));\n\n    this.index = new Document<T>({\n      document: {\n        id: this.idKey,\n        index: fields,\n      },\n      tokenize: 'forward',\n      worker: options?.enableWorker,\n      encode: encodeGreek,\n    });\n\n    this.addAll(items);\n  }\n\n  /**\n   * Add an item to the index\n   *\n   * @param item - The item to add to the index\n   */\n  public add(item: T) {\n    this.index.add(item);\n    return this;\n  }\n\n  /**\n   * Add multiple items to the index\n   *\n   * @param items - The list of items to add to the index\n   */\n  public addAll(items: T[]) {\n    items.forEach((item) => this.index.add(item));\n    return this;\n  }\n\n  /**\n   * Search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public search(documents: T[], searchTerm: string) {\n    const res = this.index.search(searchTerm);\n    const ids = getResultIds(res);\n    return findItemsByIds(\n      documents,\n      ids,\n      this.idKey as Extract<keyof T, string>\n    );\n  }\n\n  /**\n   * Asynchronously search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public async searchAsync(documents: T[], searchTerm: string) {\n    return this.index\n      .searchAsync(searchTerm)\n      .then((res) => {\n        return getResultIds(res);\n      })\n      .then((res) =>\n        findItemsByIds(documents, res, this.idKey as Extract<keyof T, string>)\n      );\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,gBAAgB;AAEzB,SAAS,mBAAmB;AAC5B,SAAS,gBAAgB,gBAAgB,oBAAoB;AAOtD,MAAM,YAA2C;AAAA,EAOtD,YAAY,OAAY,SAAiC;AACvD,SAAK,QAAQ;AACb,QAAI,WAAW,QAAQ,OAAO;AAC5B,WAAK,QAAQ,QAAQ,MAAM,QAAQ,KAAK,GAAG;AAAA,IAC7C,WAAW,EAAE,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,IAAI;AAC1C,cAAQ,MAAM,IAAI,CAAC,MAAM,WAAW,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE;AAAA,IAC7D;AAEA,QAAI,SAAmB,CAAC;AACxB,QAAI,WAAW,QAAQ,QAAQ;AAC7B,eAAS,QAAQ;AAAA,IACnB,WAAW,MAAM,CAAC,GAAG;AACnB,eAAS,eAAe,MAAM,CAAC,CAAC;AAAA,IAClC;AACA,aAAS,OACN,OAAO,CAAC,UAAU,UAAU,KAAK,KAAK,EACtC,IAAI,CAAC,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;AAEzC,SAAK,QAAQ,IAAI,SAAY;AAAA,MAC3B,UAAU;AAAA,QACR,IAAI,KAAK;AAAA,QACT,OAAO;AAAA,MACT;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,SAAS;AAAA,MACjB,QAAQ;AAAA,IACV,CAAC;AAED,SAAK,OAAO,KAAK;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IAAI,MAAS;AAClB,SAAK,MAAM,IAAI,IAAI;AACnB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,OAAO,OAAY;AACxB,UAAM,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,IAAI,CAAC;AAC5C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,OAAO,WAAgB,YAAoB;AAChD,UAAM,MAAM,KAAK,MAAM,OAAO,UAAU;AACxC,UAAM,MAAM,aAAa,GAAG;AAC5B,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,YAAY,WAAgB,YAAoB;AAC3D,WAAO,KAAK,MACT,YAAY,UAAU,EACtB,KAAK,CAAC,QAAQ;AACb,aAAO,aAAa,GAAG;AAAA,IACzB,CAAC,EACA;AAAA,MAAK,CAAC,QACL,eAAe,WAAW,KAAK,KAAK,KAAiC;AAAA,IACvE;AAAA,EACJ;AACF;",
+  "sourcesContent": ["import { Document } from 'flexsearch';\nimport { encodeGreek } from '@digigov/text-search/search/lang/gr/encoder';\nimport {\n  findItemsByIds,\n  getAllItemKeys,\n  getResultIds,\n} from '@digigov/text-search/search/utils';\nimport type { SearchIndexOptions } from '@digigov/text-search/types';\n\n/**\n * Wrapper class around third party index and search library\n *\n * @typeParam T - The type of the data that will be indexed\n */\nexport class SearchIndex<T extends Record<string, any>> {\n  /**\n   * Instance of the third party library's index\n   */\n  private index: Document<T>;\n  private idKey: string;\n\n  constructor(items: T[], options?: SearchIndexOptions<T>) {\n    this.idKey = 'id';\n    if (options && options.idKey) {\n      this.idKey = options.idKey.replace('.', ':');\n    } else if (!(items[0] && 'id' in items[0])) {\n      items = items.map((item, index) => ({ ...item, id: index }));\n    }\n\n    let fields: string[] = [];\n    if (options && options.fields) {\n      fields = options.fields;\n    } else if (items[0]) {\n      fields = getAllItemKeys(items[0]);\n    }\n    fields = fields\n      .filter((field) => field !== this.idKey)\n      .map((field) => field.replace('.', ':'));\n\n    this.index = new Document<T>({\n      document: {\n        id: this.idKey,\n        index: fields,\n      },\n      tokenize: 'forward',\n      worker: options?.enableWorker,\n      encode: encodeGreek,\n    });\n\n    this.addAll(items);\n  }\n\n  /**\n   * Add an item to the index\n   *\n   * @param item - The item to add to the index\n   */\n  public add(item: T) {\n    this.index.add(item);\n    return this;\n  }\n\n  /**\n   * Add multiple items to the index\n   *\n   * @param items - The list of items to add to the index\n   */\n  public addAll(items: T[]) {\n    items.forEach((item) => this.index.add(item));\n    return this;\n  }\n\n  /**\n   * Search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public search(documents: T[], searchTerm: string) {\n    const res = this.index.search(searchTerm);\n    const ids = getResultIds(res);\n    return findItemsByIds(\n      documents,\n      ids,\n      this.idKey as Extract<keyof T, string>\n    );\n  }\n\n  /**\n   * Asynchronously search the index for the given term\n   *\n   * @param documents - The list of documents to search\n   * @param searchTerm - The term to search for\n   * @returns The list of items that match the search term\n   */\n  public async searchAsync(documents: T[], searchTerm: string) {\n    return this.index\n      .searchAsync(searchTerm)\n      .then((res) => {\n        return getResultIds(res);\n      })\n      .then((res) =>\n        findItemsByIds(documents, res, this.idKey as Extract<keyof T, string>)\n      );\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAQA,MAAM,YAA2C;AAAA,EAOtD,YAAY,OAAY,SAAiC;AACvD,SAAK,QAAQ;AACb,QAAI,WAAW,QAAQ,OAAO;AAC5B,WAAK,QAAQ,QAAQ,MAAM,QAAQ,KAAK,GAAG;AAAA,IAC7C,WAAW,EAAE,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,IAAI;AAC1C,cAAQ,MAAM,IAAI,CAAC,MAAM,WAAW,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE;AAAA,IAC7D;AAEA,QAAI,SAAmB,CAAC;AACxB,QAAI,WAAW,QAAQ,QAAQ;AAC7B,eAAS,QAAQ;AAAA,IACnB,WAAW,MAAM,CAAC,GAAG;AACnB,eAAS,eAAe,MAAM,CAAC,CAAC;AAAA,IAClC;AACA,aAAS,OACN,OAAO,CAAC,UAAU,UAAU,KAAK,KAAK,EACtC,IAAI,CAAC,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;AAEzC,SAAK,QAAQ,IAAI,SAAY;AAAA,MAC3B,UAAU;AAAA,QACR,IAAI,KAAK;AAAA,QACT,OAAO;AAAA,MACT;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,SAAS;AAAA,MACjB,QAAQ;AAAA,IACV,CAAC;AAED,SAAK,OAAO,KAAK;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,IAAI,MAAS;AAClB,SAAK,MAAM,IAAI,IAAI;AACnB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,OAAO,OAAY;AACxB,UAAM,QAAQ,CAAC,SAAS,KAAK,MAAM,IAAI,IAAI,CAAC;AAC5C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,OAAO,WAAgB,YAAoB;AAChD,UAAM,MAAM,KAAK,MAAM,OAAO,UAAU;AACxC,UAAM,MAAM,aAAa,GAAG;AAC5B,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,YAAY,WAAgB,YAAoB;AAC3D,WAAO,KAAK,MACT,YAAY,UAAU,EACtB,KAAK,CAAC,QAAQ;AACb,aAAO,aAAa,GAAG;AAAA,IACzB,CAAC,EACA;AAAA,MAAK,CAAC,QACL,eAAe,WAAW,KAAK,KAAK,KAAiC;AAAA,IACvE;AAAA,EACJ;AACF;",
   "names": []
 }

package/search/utils/index.js

@@ -14,7 +14,7 @@ function getValueFromNestedKey(object, nestedKey) {
   const keys = nestedKey.split(":");
   let result = object;
   for (const keySegment of keys) {
-    if (result.hasOwnProperty(keySegment)) {
+    if (Object.prototype.hasOwnProperty.call(result, keySegment)) {
       result = result[keySegment];
     }
   }
@@ -23,7 +23,7 @@ function getValueFromNestedKey(object, nestedKey) {
 function getAllItemKeys(object, parentKey = "") {
   let keys = [];
   for (const key in object) {
-    if (object.hasOwnProperty(key)) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
       const currentKey = parentKey ? `${parentKey}.${key}` : key;
       if (typeof object[key] === "object" && object[key] !== null) {
         keys = keys.concat(getAllItemKeys(object[key], currentKey));

package/search/utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/search/utils.ts"],
-  "sourcesContent": ["import { SimpleDocumentSearchResultSetUnit } from 'flexsearch';\n\n/**\n * Extracts the unique item IDs from the result set\n *\n * @param result - The result set to extract the IDs from\n */\nexport function getResultIds(result: SimpleDocumentSearchResultSetUnit[]) {\n  const set = new Set<number | string>();\n  result.forEach((item) => {\n    item.result.forEach((id) => set.add(id));\n  });\n  return Array.from(set);\n}\n\n/**\n * Get the items from the list that match the given IDs\n *\n * @param items - The list of items to search through\n * @param ids - The list of IDs to search for\n * @param idKey - The key to use to find the IDs in the items\n */\nexport function findItemsByIds<T extends Record<string, any>>(\n  items: T[],\n  ids: (string | number)[],\n  idKey: Extract<keyof T, string>\n) {\n  return items.filter(\n    (item) => item && ids.includes(getValueFromNestedKey(item, idKey))\n  );\n}\n\nfunction getValueFromNestedKey(object: Record<string, any>, nestedKey: string) {\n  const keys = nestedKey.split(':');\n\n  let result = object;\n  for (const keySegment of keys) {\n    if (result.hasOwnProperty(keySegment)) {\n      result = result[keySegment];\n    }\n  }\n  return (result as unknown) as string;\n}\n\n/**\n * Recursively get all the keys from an object\n *\n * The keys are returned in the format `parentKey.childKey` for nested objects\n * and `key` for top level objects (objects that are not nested inside another object).\n *\n * @param object - The item to get the keys from\n * @param parentKey - The parent key to which the current key should be appended\n */\nexport function getAllItemKeys(\n  object: Record<string, any>,\n  parentKey: string = ''\n): string[] {\n  let keys: string[] = [];\n  for (const key in object) {\n    if (object.hasOwnProperty(key)) {\n      const currentKey = parentKey ? `${parentKey}.${key}` : key;\n\n      if (typeof object[key] === 'object' && object[key] !== null) {\n        keys = keys.concat(getAllItemKeys(object[key], currentKey));\n      } else {\n        keys.push(currentKey);\n      }\n    }\n  }\n\n  return keys;\n}\n"],
-  "mappings": "AAOO,SAAS,aAAa,QAA6C;AACxE,QAAM,MAAM,oBAAI,IAAqB;AACrC,SAAO,QAAQ,CAAC,SAAS;AACvB,SAAK,OAAO,QAAQ,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;AAAA,EACzC,CAAC;AACD,SAAO,MAAM,KAAK,GAAG;AACvB;AASO,SAAS,eACd,OACA,KACA,OACA;AACA,SAAO,MAAM;AAAA,IACX,CAAC,SAAS,QAAQ,IAAI,SAAS,sBAAsB,MAAM,KAAK,CAAC;AAAA,EACnE;AACF;AAEA,SAAS,sBAAsB,QAA6B,WAAmB;AAC7E,QAAM,OAAO,UAAU,MAAM,GAAG;AAEhC,MAAI,SAAS;AACb,aAAW,cAAc,MAAM;AAC7B,QAAI,OAAO,eAAe,UAAU,GAAG;AACrC,eAAS,OAAO,UAAU;AAAA,IAC5B;AAAA,EACF;AACA,SAAQ;AACV;AAWO,SAAS,eACd,QACA,YAAoB,IACV;AACV,MAAI,OAAiB,CAAC;AACtB,aAAW,OAAO,QAAQ;AACxB,QAAI,OAAO,eAAe,GAAG,GAAG;AAC9B,YAAM,aAAa,YAAY,GAAG,SAAS,IAAI,GAAG,KAAK;AAEvD,UAAI,OAAO,OAAO,GAAG,MAAM,YAAY,OAAO,GAAG,MAAM,MAAM;AAC3D,eAAO,KAAK,OAAO,eAAe,OAAO,GAAG,GAAG,UAAU,CAAC;AAAA,MAC5D,OAAO;AACL,aAAK,KAAK,UAAU;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
+  "sourcesContent": ["import { SimpleDocumentSearchResultSetUnit } from 'flexsearch';\n\n/**\n * Extracts the unique item IDs from the result set\n *\n * @param result - The result set to extract the IDs from\n */\nexport function getResultIds(result: SimpleDocumentSearchResultSetUnit[]) {\n  const set = new Set<number | string>();\n  result.forEach((item) => {\n    item.result.forEach((id) => set.add(id));\n  });\n  return Array.from(set);\n}\n\n/**\n * Get the items from the list that match the given IDs\n *\n * @param items - The list of items to search through\n * @param ids - The list of IDs to search for\n * @param idKey - The key to use to find the IDs in the items\n */\nexport function findItemsByIds<T extends Record<string, any>>(\n  items: T[],\n  ids: (string | number)[],\n  idKey: Extract<keyof T, string>\n) {\n  return items.filter(\n    (item) => item && ids.includes(getValueFromNestedKey(item, idKey))\n  );\n}\n\nfunction getValueFromNestedKey(object: Record<string, any>, nestedKey: string) {\n  const keys = nestedKey.split(':');\n\n  let result = object;\n  for (const keySegment of keys) {\n    if (Object.prototype.hasOwnProperty.call(result, keySegment)) {\n      result = result[keySegment];\n    }\n  }\n  return result as unknown as string;\n}\n\n/**\n * Recursively get all the keys from an object\n *\n * The keys are returned in the format `parentKey.childKey` for nested objects\n * and `key` for top level objects (objects that are not nested inside another object).\n *\n * @param object - The item to get the keys from\n * @param parentKey - The parent key to which the current key should be appended\n */\nexport function getAllItemKeys(\n  object: Record<string, any>,\n  parentKey = ''\n): string[] {\n  let keys: string[] = [];\n  for (const key in object) {\n    if (Object.prototype.hasOwnProperty.call(object, key)) {\n      const currentKey = parentKey ? `${parentKey}.${key}` : key;\n\n      if (typeof object[key] === 'object' && object[key] !== null) {\n        keys = keys.concat(getAllItemKeys(object[key], currentKey));\n      } else {\n        keys.push(currentKey);\n      }\n    }\n  }\n\n  return keys;\n}\n"],
+  "mappings": "AAOO,SAAS,aAAa,QAA6C;AACxE,QAAM,MAAM,oBAAI,IAAqB;AACrC,SAAO,QAAQ,CAAC,SAAS;AACvB,SAAK,OAAO,QAAQ,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;AAAA,EACzC,CAAC;AACD,SAAO,MAAM,KAAK,GAAG;AACvB;AASO,SAAS,eACd,OACA,KACA,OACA;AACA,SAAO,MAAM;AAAA,IACX,CAAC,SAAS,QAAQ,IAAI,SAAS,sBAAsB,MAAM,KAAK,CAAC;AAAA,EACnE;AACF;AAEA,SAAS,sBAAsB,QAA6B,WAAmB;AAC7E,QAAM,OAAO,UAAU,MAAM,GAAG;AAEhC,MAAI,SAAS;AACb,aAAW,cAAc,MAAM;AAC7B,QAAI,OAAO,UAAU,eAAe,KAAK,QAAQ,UAAU,GAAG;AAC5D,eAAS,OAAO,UAAU;AAAA,IAC5B;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,eACd,QACA,YAAY,IACF;AACV,MAAI,OAAiB,CAAC;AACtB,aAAW,OAAO,QAAQ;AACxB,QAAI,OAAO,UAAU,eAAe,KAAK,QAAQ,GAAG,GAAG;AACrD,YAAM,aAAa,YAAY,GAAG,SAAS,IAAI,GAAG,KAAK;AAEvD,UAAI,OAAO,OAAO,GAAG,MAAM,YAAY,OAAO,GAAG,MAAM,MAAM;AAC3D,eAAO,KAAK,OAAO,eAAe,OAAO,GAAG,GAAG,UAAU,CAAC;AAAA,MAC5D,OAAO;AACL,aAAK,KAAK,UAAU;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
   "names": []
 }

package/src/hook.spec.ts

@@ -1,6 +1,8 @@
-import { act, renderHook } from '@testing-library/react-hooks';
-import useSearch from './hook';
-import documents from './test-utils/data.json';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import useSearch from '@digigov/text-search/hook';
+import documents from '@digigov/text-search/test-utils/data.json';
+
+// TODO: This test file is currently being ignored. Fix flexsearch types issue
 
 describe('loading', () => {
   it('should start when searching', async () => {
@@ -10,33 +12,27 @@ describe('loading', () => {
     expect(result.current.loading).toBe(true);
   });
   it('should stop after search is completed', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Anastasia')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Anastasia'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
   });
 });
 
 describe('reset', () => {
   it('should change the returned result back to the initial data', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Anastasia')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Anastasia'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     act(() => result.current.reset());
     expect(result.current.data).toEqual(documents);
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
   });
 });
 
@@ -45,23 +41,20 @@ describe('search', () => {
     const { result } = renderHook(() => useSearch(documents));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual(documents);
   });
   it('should return an empty array when there are no relevant items', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'fajsgsdgsdgsd')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'fajsgsdgsdgsd'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual([]);
   });
   it('should return an empty array when relevant field is not indexed', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
+    const { result } = renderHook(() =>
       useSearch(documents, 'Anastasia', {
         indexing: {
           fields: ['lastName'], // missing 'firstName'
@@ -72,38 +65,31 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual([]);
   });
   it('should return a single result when there is only one relevant item', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Anastasia')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Anastasia'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');
   });
   it('should return multiple results when there are multiple relevant items', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Kari')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Kari'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBeGreaterThanOrEqual(2);
 
     result.current.data.forEach((item) => {
@@ -112,43 +98,37 @@ describe('search', () => {
     });
   });
   it('should work with a partial query', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'anast')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'anast'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');
   });
   it('should work with nested field if not explicitly stated', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Titanic')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Titanic'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult.address).values()).toContain('Titanic');
   });
   it('should work with nested field if explicitly stated', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
+    const { result } = renderHook(() =>
       useSearch(documents, 'Titanic', {
         indexing: {
           fields: ['address.city'],
@@ -159,18 +139,17 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult.address).values()).toContain('Titanic');
   });
   it('should work with nested ID', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
+    const { result } = renderHook(() =>
       useSearch(documents, 'Titanic', {
         indexing: {
           idKey: 'address.street',
@@ -181,55 +160,48 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult.address).values()).toContain('Titanic');
   });
   it('should work with indexed Greek characters and Latin query', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Markos')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Markos'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Μάρκος');
   });
   it('should work with indexed Greek characters and Greek query', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Μάρκος')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Μάρκος'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Μάρκος');
   });
   it('should react to changes in the documents list', async () => {
     const emptyDocuments: typeof documents = [];
-    const { result, rerender, waitForNextUpdate } = renderHook(
+    const { result, rerender } = renderHook(
       ({ documents }) => useSearch(documents, 'Anastasia'),
       {
         initialProps: { documents: emptyDocuments },
@@ -238,8 +210,7 @@ describe('search', () => {
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual([]);
 
     rerender({ documents });
@@ -249,18 +220,17 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual([]);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');
   });
   it('should react to changes in the search query', async () => {
-    const { result, rerender, waitForNextUpdate } = renderHook(
+    const { result, rerender } = renderHook(
       ({ query }) => useSearch(documents, query),
       {
         initialProps: { query: '' },
@@ -276,12 +246,11 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');

package/src/hook.ts

@@ -1,6 +1,6 @@
 import { useCallback, useMemo, useState } from 'react';
-import SearchIndex from './search';
-import { UseSearchOptions } from './types';
+import SearchIndex from '@digigov/text-search/search';
+import { UseSearchOptions } from '@digigov/text-search/types';
 
 /**
  * Hook for searching through a list of documents
@@ -24,10 +24,10 @@ export default function useSearch<T extends Record<string, any>>(
 
   const indexing = options?.indexing;
 
-  const index = useMemo(() => new SearchIndex(documents, indexing), [
-    documents,
-    indexing,
-  ]);
+  const index = useMemo(
+    () => new SearchIndex(documents, indexing),
+    [documents, indexing]
+  );
 
   const search = useCallback(() => {
     if (query) {
@@ -35,6 +35,7 @@ export default function useSearch<T extends Record<string, any>>(
       index
         .searchAsync(documents, query)
         .then((data) => setData(data))
+        .catch(() => setData([]))
         .finally(() => setLoading(false));
     } else {
       setData(documents);

package/src/index.ts

@@ -1,4 +1,4 @@
-import useSearch from './hook';
+import useSearch from '@digigov/text-search/hook';
 
 export default useSearch;
-export * from './search';
+export * from '@digigov/text-search/search';

package/src/search/__tests__/utils.spec.ts

@@ -1,5 +1,9 @@
 import type { SimpleDocumentSearchResultSetUnit as ResultType } from 'flexsearch';
-import { findItemsByIds, getAllItemKeys, getResultIds } from '../utils';
+import {
+  findItemsByIds,
+  getAllItemKeys,
+  getResultIds,
+} from '@digigov/text-search/search/utils';
 
 describe('utils', () => {
   describe('getResultIds', () => {

package/src/search/index.ts

@@ -1,3 +1,3 @@
-import { SearchIndex } from './search-index';
+import { SearchIndex } from '@digigov/text-search/search/search-index';
 
 export default SearchIndex;

package/src/search/lang/gr/encoder.ts

@@ -1,7 +1,7 @@
-import { greekToGreeklishMap } from './normalization-map';
+import { greekToGreeklishMap } from '@digigov/text-search/search/lang/gr/normalization-map';
 
-const whitespaceRegex = /[\p{Z}\p{S}\p{P}\p{C}]+/u;
-const diacriticsRegex = /[\u0300-\u036f]/g;
+const whitespaceRegex = new RegExp('[p{Z}p{S}p{P}p{C}]+', 'u');
+const diacriticsRegex = new RegExp('[\u0300-\u036f]', 'g');
 const greekCharsRegex = new RegExp(
   Object.keys(greekToGreeklishMap).join('|'),
   'igu'
@@ -22,6 +22,10 @@ export function encodeGreek(str: string) {
     .toLowerCase()
     .normalize('NFD')
     .replace(diacriticsRegex, '')
-    .replace(greekCharsRegex, (match) => (greekToGreeklishMap as any)[match])
+    .replace(greekCharsRegex, (match) =>
+      match in greekToGreeklishMap
+        ? greekToGreeklishMap[match as keyof typeof greekToGreeklishMap]
+        : match
+    )
     .split(whitespaceRegex);
 }

package/src/search/search-index.ts

@@ -1,7 +1,11 @@
 import { Document } from 'flexsearch';
-import type { SearchIndexOptions } from '../types';
-import { encodeGreek } from './lang/gr/encoder';
-import { findItemsByIds, getAllItemKeys, getResultIds } from './utils';
+import { encodeGreek } from '@digigov/text-search/search/lang/gr/encoder';
+import {
+  findItemsByIds,
+  getAllItemKeys,
+  getResultIds,
+} from '@digigov/text-search/search/utils';
+import type { SearchIndexOptions } from '@digigov/text-search/types';
 
 /**
  * Wrapper class around third party index and search library

package/src/search/utils.ts

@@ -35,11 +35,11 @@ function getValueFromNestedKey(object: Record<string, any>, nestedKey: string) {
 
   let result = object;
   for (const keySegment of keys) {
-    if (result.hasOwnProperty(keySegment)) {
+    if (Object.prototype.hasOwnProperty.call(result, keySegment)) {
       result = result[keySegment];
     }
   }
-  return (result as unknown) as string;
+  return result as unknown as string;
 }
 
 /**
@@ -53,11 +53,11 @@ function getValueFromNestedKey(object: Record<string, any>, nestedKey: string) {
  */
 export function getAllItemKeys(
   object: Record<string, any>,
-  parentKey: string = ''
+  parentKey = ''
 ): string[] {
   let keys: string[] = [];
   for (const key in object) {
-    if (object.hasOwnProperty(key)) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
       const currentKey = parentKey ? `${parentKey}.${key}` : key;
 
       if (typeof object[key] === 'object' && object[key] !== null) {

package/src/types.ts

@@ -59,7 +59,7 @@ export type NestedKeyOf<T> = T extends Primitive
 type DeepSubKeys<T, P extends keyof T & string> = T[P] extends (infer Inner)[]
   ? `${P}.${NestedKeyOf<Inner>}`
   : T[P] extends object
-  ? `${P}.${NestedKeyOf<T[P]>}`
-  : never;
+    ? `${P}.${NestedKeyOf<T[P]>}`
+    : never;
 
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;