@digigov/text-search 0.1.0-47312a12

package/search/__tests__/utils.spec.js

@@ -0,0 +1,81 @@
+import { findItemsByIds, getAllItemKeys, getResultIds } from "../utils";
+describe('utils', function () {
+  describe('getResultIds', function () {
+    it('should return the ids of the results without duplicates', function () {
+      var result = [{
+        field: 'title',
+        result: [1, 2]
+      }, {
+        field: 'description',
+        result: [2, 3]
+      }, {
+        field: 'tag',
+        result: [1, 2, 3, 4]
+      }];
+      expect(getResultIds(result)).toEqual([1, 2, 3, 4]);
+    });
+    it('should return an empty array if there are no results', function () {
+      var result = [];
+      expect(getResultIds(result)).toEqual([]);
+    });
+  });
+  describe('findItemsByIds', function () {
+    it('should return the items that match the given ids', function () {
+      var items = [{
+        id: 1,
+        name: 'Anastasia'
+      }, {
+        id: 2,
+        name: 'Bob'
+      }, {
+        id: 3,
+        name: 'Cindy'
+      }];
+      var ids = [1, 3];
+      expect(findItemsByIds(items, ids, 'id')).toEqual([{
+        id: 1,
+        name: 'Anastasia'
+      }, {
+        id: 3,
+        name: 'Cindy'
+      }]);
+    });
+    it('should return an empty array if there are no items', function () {
+      var items = [];
+      var ids = [1, 3];
+      expect(findItemsByIds(items, ids, 'id')).toEqual([]);
+    });
+    it('should return an empty array if there are no ids', function () {
+      var items = [{
+        id: 1,
+        name: 'Anastasia'
+      }, {
+        id: 2,
+        name: 'Bob'
+      }, {
+        id: 3,
+        name: 'Cindy'
+      }];
+      var ids = [];
+      expect(findItemsByIds(items, ids, 'id')).toEqual([]);
+    });
+  });
+  describe('getAllItemKeys', function () {
+    it('should return all the keys for the given item', function () {
+      var item = {
+        id: 1,
+        name: 'Anastasia',
+        address: {
+          street: '123 Main St',
+          city: 'New York',
+          state: 'NY'
+        }
+      };
+      expect(getAllItemKeys(item)).toEqual(['id', 'name', 'address.street', 'address.city', 'address.state']);
+    });
+    it('should return an empty array if item is an empty object', function () {
+      var item = {};
+      expect(getAllItemKeys(item)).toEqual([]);
+    });
+  });
+});

package/search/index.d.ts

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

package/search/index.js

@@ -0,0 +1,2 @@
+import { SearchIndex } from "./search-index";
+export default SearchIndex;

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

@@ -0,0 +1,11 @@
+/**
+ * Encode a string containing greek characters to greeklish
+ *
+ * This function is used to encode and tokenize a string containing greek characters.
+ * It replaces greek characters with their latin counterparts, while also removing
+ * any diacritics.
+ *
+ * @param str - The string to encode
+ * @returns An array of encoded words
+ */
+export declare function encodeGreek(str: string): string[];

package/search/lang/gr/encoder.js

@@ -0,0 +1,20 @@
+import { greekToGreeklishMap } from "./normalization-map";
+var whitespaceRegex = /(?:[\0-\/:-@\[-`\{-\xA9\xAB-\xB1\xB4\xB6-\xB8\xBB\xBF\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0378\u0379\u037E\u0380-\u0385\u0387\u038B\u038D\u03A2\u03F6\u0482\u0530\u0557\u0558\u055A-\u055F\u0589-\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05EB-\u05EE\u05F3-\u060F\u061B-\u061F\u066A-\u066D\u06D4\u06DD\u06DE\u06E9\u06FD\u06FE\u0700-\u070F\u074B\u074C\u07B2-\u07BF\u07F6-\u07F9\u07FB\u07FC\u07FE\u07FF\u082E-\u083F\u085C-\u085F\u086B-\u086F\u0888\u088F-\u0897\u08E2\u0964\u0965\u0970\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09F2\u09F3\u09FA\u09FB\u09FD\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF0-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B70\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BF3-\u0BFF\u0C0D\u0C11\u0C29\u0C3A\u0C3B\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B\u0C5C\u0C5E\u0C5F\u0C64\u0C65\u0C70-\u0C77\u0C7F\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDC\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D4F-\u0D53\u0D64\u0D65\u0D79\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF4-\u0E00\u0E3B-\u0E3F\u0E4F\u0E5A-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F01-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0F3A-\u0F3D\u0F48\u0F6D-\u0F70\u0F85\u0F98\u0FBD-\u0FC5\u0FC7-\u0FFF\u104A-\u104F\u109E\u109F\u10C6\u10C8-\u10CC\u10CE\u10CF\u10FB\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u1360-\u1368\u137D-\u137F\u1390-\u139F\u13F6\u13F7\u13FE-\u1400\u166D\u166E\u1680\u169B-\u169F\u16EB-\u16ED\u16F9-\u16FF\u1716-\u171E\u1735-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17D4-\u17D6\u17D8-\u17DB\u17DE\u17DF\u17EA-\u17EF\u17FA-\u180A\u180E\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u1945\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19FF\u1A1C-\u1A1F\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1AA6\u1AA8-\u1AAF\u1ACF-\u1AFF\u1B4D-\u1B4F\u1B5A-\u1B6A\u1B74-\u1B7F\u1BF4-\u1BFF\u1C38-\u1C3F\u1C4A-\u1C4C\u1C7E\u1C7F\u1C89-\u1C8F\u1CBB\u1CBC\u1CC0-\u1CCF\u1CD3\u1CFB-\u1CFF\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FBD\u1FBF-\u1FC1\u1FC5\u1FCD-\u1FCF\u1FD4\u1FD5\u1FDC-\u1FDF\u1FED-\u1FF1\u1FF5\u1FFD-\u206F\u2072\u2073\u207A-\u207E\u208A-\u208F\u209D-\u20CF\u20F1-\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A-\u245F\u249C-\u24E9\u2500-\u2775\u2794-\u2BFF\u2CE5-\u2CEA\u2CF4-\u2CFC\u2CFE\u2CFF\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D70-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E00-\u2E2E\u2E30-\u3004\u3008-\u3020\u3030\u3036\u3037\u303D-\u3040\u3097\u3098\u309B\u309C\u30A0\u30FB\u3100-\u3104\u3130\u318F-\u3191\u3196-\u319F\u31C0-\u31EF\u3200-\u321F\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA48D-\uA4CF\uA4FE\uA4FF\uA60D-\uA60F\uA62C-\uA63F\uA673\uA67E\uA6F2-\uA716\uA720\uA721\uA789\uA78A\uA7CB-\uA7CF\uA7D2\uA7D4\uA7DA-\uA7F1\uA828-\uA82B\uA82D-\uA82F\uA836-\uA83F\uA874-\uA87F\uA8C6-\uA8CF\uA8DA-\uA8DF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA954-\uA95F\uA97D-\uA97F\uA9C1-\uA9CE\uA9DA-\uA9DF\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A-\uAA5F\uAA77-\uAA79\uAAC3-\uAADA\uAADE\uAADF\uAAF0\uAAF1\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB5B\uAB6A-\uAB6F\uABEB\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB29\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBB2-\uFBD2\uFD3E-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFC-\uFDFF\uFE10-\uFE1F\uFE30-\uFE6F\uFE75\uFEFD-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF40\uFF5B-\uFF65\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDD06\uDD34-\uDD3F\uDD79-\uDD89\uDD8C-\uDDFC\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDF9F\uDFC4-\uDFC7\uDFD0\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6F\uDD7B\uDD8B\uDD93\uDD96\uDDA2\uDDB2\uDDBA\uDDBD-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDF7F\uDF86\uDFB1\uDFBB-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC57\uDC77\uDC78\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1F\uDD3A-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE5F\uDE7F\uDEA0-\uDEBF\uDEC8\uDEE7-\uDEEA\uDEF0-\uDEFF\uDF36-\uDF3F\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAD-\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF55-\uDF6F\uDF86-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC47-\uDC51\uDC76-\uDC7E\uDCBB-\uDCC1\uDCC3-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD40-\uDD43\uDD48-\uDD4F\uDD74\uDD75\uDD77-\uDD7F\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDE0\uDDF5-\uDDFF\uDE12\uDE38-\uDE3D\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEA9-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC4B-\uDC4F\uDC5A-\uDC5D\uDC62-\uDC7F\uDCC6\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDC1-\uDDD7\uDDDE-\uDDFF\uDE41-\uDE43\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF3C-\uDF3F\uDF47-\uDFFF]|\uD806[\uDC3B-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD44-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE2\uDDE5-\uDDFF\uDE3F-\uDE46\uDE48-\uDE4F\uDE9A-\uDE9C\uDE9E-\uDEAF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC41-\uDC4F\uDC6D-\uDC71\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF7-\uDFAF\uDFB1-\uDFBF\uDFD5-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80E-\uD810\uD812-\uD819\uD824-\uD82A\uD82D\uD82E\uD830-\uD832\uD83D\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80B[\uDC00-\uDF8F\uDFF1-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6F\uDEBF\uDECA-\uDECF\uDEEE\uDEEF\uDEF5-\uDEFF\uDF37-\uDF3F\uDF44-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE97-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE2\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82B[\uDC00-\uDFEF\uDFF4\uDFFC\uDFFF]|\uD82C[\uDD23-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A-\uDC9C\uDC9F-\uDFFF]|\uD833[\uDC00-\uDEFF\uDF2E\uDF2F\uDF47-\uDFFF]|\uD834[\uDC00-\uDD64\uDD6A-\uDD6C\uDD73-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDE41\uDE45-\uDEDF\uDEF4-\uDF5F\uDF79-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3\uDFCC\uDFCD]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD837[\uDC00-\uDEFF\uDF1F-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD4F-\uDE8F\uDEAF-\uDEBF\uDEFA-\uDFFF]|\uD839[\uDC00-\uDFDF\uDFE7\uDFEC\uDFEF\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDFFF]|\uD83B[\uDC00-\uDC70\uDCAC\uDCB0\uDCB5-\uDD00\uDD2E\uDD3E-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDFFF]|\uD83C[\uDC00-\uDCFF\uDD0D-\uDFFF]|\uD83E[\uDC00-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEE0-\uDEFF]|\uD86D[\uDF39-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+/;
+var diacriticsRegex = /[\u0300-\u036f]/g;
+var greekCharsRegex = new RegExp(Object.keys(greekToGreeklishMap).join('|'), 'igu');
+/**
+ * Encode a string containing greek characters to greeklish
+ *
+ * This function is used to encode and tokenize a string containing greek characters.
+ * It replaces greek characters with their latin counterparts, while also removing
+ * any diacritics.
+ *
+ * @param str - The string to encode
+ * @returns An array of encoded words
+ */
+
+export function encodeGreek(str) {
+  return ('' + str).toLowerCase().normalize('NFD').replace(diacriticsRegex, '').replace(greekCharsRegex, function (match) {
+    return greekToGreeklishMap[match];
+  }).split(whitespaceRegex);
+}

package/search/lang/gr/normalization-map.d.ts

@@ -0,0 +1,100 @@
+export declare const greekToGreeklishMap: {
+    ΓΧ: string;
+    γχ: string;
+    ΤΘ: string;
+    τθ: string;
+    θη: string;
+    Θη: string;
+    ΘΗ: string;
+    αυ: string;
+    Αυ: string;
+    ΑΥ: string;
+    ευ: string;
+    εύ: string;
+    εϋ: string;
+    εΰ: string;
+    Ευ: string;
+    Εύ: string;
+    Εϋ: string;
+    Εΰ: string;
+    ΕΥ: string;
+    ου: string;
+    ού: string;
+    οϋ: string;
+    οΰ: string;
+    Ου: string;
+    Ού: string;
+    Οϋ: string;
+    Οΰ: string;
+    ΟΥ: string;
+    Α: string;
+    α: string;
+    ά: string;
+    Ά: string;
+    Β: string;
+    β: string;
+    Γ: string;
+    γ: string;
+    Δ: string;
+    δ: string;
+    Ε: string;
+    ε: string;
+    έ: string;
+    Έ: string;
+    Ζ: string;
+    ζ: string;
+    Η: string;
+    η: string;
+    ή: string;
+    Ή: string;
+    Θ: string;
+    θ: string;
+    Ι: string;
+    Ϊ: string;
+    ι: string;
+    ί: string;
+    ΐ: string;
+    ϊ: string;
+    Ί: string;
+    Κ: string;
+    κ: string;
+    Λ: string;
+    λ: string;
+    Μ: string;
+    μ: string;
+    Ν: string;
+    ν: string;
+    Ξ: string;
+    ξ: string;
+    Ο: string;
+    ο: string;
+    Ό: string;
+    ό: string;
+    Π: string;
+    π: string;
+    Ρ: string;
+    ρ: string;
+    Σ: string;
+    σ: string;
+    Τ: string;
+    τ: string;
+    Υ: string;
+    Ύ: string;
+    Ϋ: string;
+    ΰ: string;
+    ύ: string;
+    ϋ: string;
+    υ: string;
+    Φ: string;
+    φ: string;
+    Χ: string;
+    χ: string;
+    Ψ: string;
+    ψ: string;
+    Ω: string;
+    ω: string;
+    Ώ: string;
+    ώ: string;
+    ς: string;
+    ';': string;
+};

package/search/lang/gr/normalization-map.js

@@ -0,0 +1,100 @@
+export var greekToGreeklishMap = {
+  ΓΧ: 'GX',
+  γχ: 'gx',
+  ΤΘ: 'T8',
+  τθ: 't8',
+  θη: '8h',
+  Θη: '8h',
+  ΘΗ: '8H',
+  αυ: 'au',
+  Αυ: 'Au',
+  ΑΥ: 'AY',
+  ευ: 'eu',
+  εύ: 'eu',
+  εϋ: 'ey',
+  εΰ: 'ey',
+  Ευ: 'Eu',
+  Εύ: 'Eu',
+  Εϋ: 'Ey',
+  Εΰ: 'Ey',
+  ΕΥ: 'EY',
+  ου: 'ou',
+  ού: 'ou',
+  οϋ: 'oy',
+  οΰ: 'oy',
+  Ου: 'Ou',
+  Ού: 'Ou',
+  Οϋ: 'Oy',
+  Οΰ: 'Oy',
+  ΟΥ: 'OY',
+  Α: 'A',
+  α: 'a',
+  ά: 'a',
+  Ά: 'A',
+  Β: 'B',
+  β: 'b',
+  Γ: 'G',
+  γ: 'g',
+  Δ: 'D',
+  δ: 'd',
+  Ε: 'E',
+  ε: 'e',
+  έ: 'e',
+  Έ: 'E',
+  Ζ: 'Z',
+  ζ: 'z',
+  Η: 'H',
+  η: 'h',
+  ή: 'h',
+  Ή: 'H',
+  Θ: 'TH',
+  θ: 'th',
+  Ι: 'I',
+  Ϊ: 'I',
+  ι: 'i',
+  ί: 'i',
+  ΐ: 'i',
+  ϊ: 'i',
+  Ί: 'I',
+  Κ: 'K',
+  κ: 'k',
+  Λ: 'L',
+  λ: 'l',
+  Μ: 'M',
+  μ: 'm',
+  Ν: 'N',
+  ν: 'n',
+  Ξ: 'KS',
+  ξ: 'ks',
+  Ο: 'O',
+  ο: 'o',
+  Ό: 'O',
+  ό: 'o',
+  Π: 'P',
+  π: 'p',
+  Ρ: 'R',
+  ρ: 'r',
+  Σ: 'S',
+  σ: 's',
+  Τ: 'T',
+  τ: 't',
+  Υ: 'Y',
+  Ύ: 'Y',
+  Ϋ: 'Y',
+  ΰ: 'y',
+  ύ: 'y',
+  ϋ: 'y',
+  υ: 'y',
+  Φ: 'F',
+  φ: 'f',
+  Χ: 'X',
+  χ: 'x',
+  Ψ: 'Ps',
+  ψ: 'ps',
+  Ω: 'w',
+  ω: 'w',
+  Ώ: 'w',
+  ώ: 'w',
+  ς: 's',
+  ';': '?'
+};

package/search/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "main": "../cjs/search/index.js"
+}

package/search/search-index.d.ts

@@ -0,0 +1,42 @@
+import type { SearchIndexOptions } from '../types';
+/**
+ * Wrapper class around third party index and search library
+ *
+ * @typeParam T - The type of the data that will be indexed
+ */
+export declare class SearchIndex<T extends Record<string, any>> {
+    /**
+     * Instance of the third party library's index
+     */
+    private index;
+    private idKey;
+    constructor(items: T[], options?: SearchIndexOptions<T>);
+    /**
+     * Add an item to the index
+     *
+     * @param item - The item to add to the index
+     */
+    add(item: T): this;
+    /**
+     * Add multiple items to the index
+     *
+     * @param items - The list of items to add to the index
+     */
+    addAll(items: T[]): this;
+    /**
+     * Search the index for the given term
+     *
+     * @param documents - The list of documents to search
+     * @param searchTerm - The term to search for
+     * @returns The list of items that match the search term
+     */
+    search(documents: T[], searchTerm: string): T[];
+    /**
+     * Asynchronously search the index for the given term
+     *
+     * @param documents - The list of documents to search
+     * @param searchTerm - The term to search for
+     * @returns The list of items that match the search term
+     */
+    searchAsync(documents: T[], searchTerm: string): Promise<T[]>;
+}

package/search/search-index.js

@@ -0,0 +1,150 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/extends";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return generator._invoke = function (innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; }(innerFn, self, context), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; this._invoke = function (method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); }; } function maybeInvokeDelegate(delegate, context) { var method = delegate.iterator[context.method]; if (undefined === method) { if (context.delegate = null, "throw" === context.method) { if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel; context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) { if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; } return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (object) { var keys = []; for (var key in object) { keys.push(key); } return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) { "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); } }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, "catch": function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+
+import { Document } from 'flexsearch';
+import { encodeGreek } from "./lang/gr/encoder";
+import { findItemsByIds, getAllItemKeys, getResultIds } from "./utils";
+/**
+ * Wrapper class around third party index and search library
+ *
+ * @typeParam T - The type of the data that will be indexed
+ */
+
+export var SearchIndex = /*#__PURE__*/function () {
+  /**
+   * Instance of the third party library's index
+   */
+  function SearchIndex(items, options) {
+    var _this = this;
+
+    _classCallCheck(this, SearchIndex);
+
+    this.index = void 0;
+    this.idKey = void 0;
+    this.idKey = 'id';
+
+    if (options && options.idKey) {
+      this.idKey = options.idKey.replace('.', ':');
+    } else if (!(items[0] && 'id' in items[0])) {
+      items = items.map(function (item, index) {
+        return _extends({}, item, {
+          id: index
+        });
+      });
+    }
+
+    var fields = [];
+
+    if (options && options.fields) {
+      fields = options.fields;
+    } else if (items[0]) {
+      fields = getAllItemKeys(items[0]);
+    }
+
+    fields = fields.filter(function (field) {
+      return field !== _this.idKey;
+    }).map(function (field) {
+      return field.replace('.', ':');
+    });
+    this.index = new Document({
+      document: {
+        id: this.idKey,
+        index: fields
+      },
+      tokenize: 'forward',
+      worker: options === null || options === void 0 ? void 0 : options.enableWorker,
+      encode: encodeGreek
+    });
+    this.addAll(items);
+  }
+  /**
+   * Add an item to the index
+   *
+   * @param item - The item to add to the index
+   */
+
+
+  _createClass(SearchIndex, [{
+    key: "add",
+    value: function add(item) {
+      this.index.add(item);
+      return this;
+    }
+    /**
+     * Add multiple items to the index
+     *
+     * @param items - The list of items to add to the index
+     */
+
+  }, {
+    key: "addAll",
+    value: function addAll(items) {
+      var _this2 = this;
+
+      items.forEach(function (item) {
+        return _this2.index.add(item);
+      });
+      return this;
+    }
+    /**
+     * Search the index for the given term
+     *
+     * @param documents - The list of documents to search
+     * @param searchTerm - The term to search for
+     * @returns The list of items that match the search term
+     */
+
+  }, {
+    key: "search",
+    value: function search(documents, searchTerm) {
+      var res = this.index.search(searchTerm);
+      var ids = getResultIds(res);
+      return findItemsByIds(documents, ids, this.idKey);
+    }
+    /**
+     * Asynchronously search the index for the given term
+     *
+     * @param documents - The list of documents to search
+     * @param searchTerm - The term to search for
+     * @returns The list of items that match the search term
+     */
+
+  }, {
+    key: "searchAsync",
+    value: function () {
+      var _searchAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(documents, searchTerm) {
+        var _this3 = this;
+
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return", this.index.searchAsync(searchTerm).then(function (res) {
+                  return getResultIds(res);
+                }).then(function (res) {
+                  return findItemsByIds(documents, res, _this3.idKey);
+                }));
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function searchAsync(_x, _x2) {
+        return _searchAsync.apply(this, arguments);
+      }
+
+      return searchAsync;
+    }()
+  }]);
+
+  return SearchIndex;
+}();

package/search/utils.d.ts

@@ -0,0 +1,25 @@
+import { SimpleDocumentSearchResultSetUnit } from 'flexsearch';
+/**
+ * Extracts the unique item IDs from the result set
+ *
+ * @param result - The result set to extract the IDs from
+ */
+export declare function getResultIds(result: SimpleDocumentSearchResultSetUnit[]): (string | number)[];
+/**
+ * Get the items from the list that match the given IDs
+ *
+ * @param items - The list of items to search through
+ * @param ids - The list of IDs to search for
+ * @param idKey - The key to use to find the IDs in the items
+ */
+export declare function findItemsByIds<T extends Record<string, any>>(items: T[], ids: (string | number)[], idKey: Extract<keyof T, string>): T[];
+/**
+ * Recursively get all the keys from an object
+ *
+ * The keys are returned in the format `parentKey.childKey` for nested objects
+ * and `key` for top level objects (objects that are not nested inside another object).
+ *
+ * @param object - The item to get the keys from
+ * @param parentKey - The parent key to which the current key should be appended
+ */
+export declare function getAllItemKeys(object: Record<string, any>, parentKey?: string): string[];

package/search/utils.js

@@ -0,0 +1,88 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/**
+ * Extracts the unique item IDs from the result set
+ *
+ * @param result - The result set to extract the IDs from
+ */
+export function getResultIds(result) {
+  var set = new Set();
+  result.forEach(function (item) {
+    item.result.forEach(function (id) {
+      return set.add(id);
+    });
+  });
+  return Array.from(set);
+}
+/**
+ * Get the items from the list that match the given IDs
+ *
+ * @param items - The list of items to search through
+ * @param ids - The list of IDs to search for
+ * @param idKey - The key to use to find the IDs in the items
+ */
+
+export function findItemsByIds(items, ids, idKey) {
+  return items.filter(function (item) {
+    return item && ids.includes(getValueFromNestedKey(item, idKey));
+  });
+}
+
+function getValueFromNestedKey(object, nestedKey) {
+  var keys = nestedKey.split(':');
+  var result = object;
+
+  var _iterator = _createForOfIteratorHelper(keys),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var keySegment = _step.value;
+
+      if (result.hasOwnProperty(keySegment)) {
+        result = result[keySegment];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return result;
+}
+/**
+ * Recursively get all the keys from an object
+ *
+ * The keys are returned in the format `parentKey.childKey` for nested objects
+ * and `key` for top level objects (objects that are not nested inside another object).
+ *
+ * @param object - The item to get the keys from
+ * @param parentKey - The parent key to which the current key should be appended
+ */
+
+
+export function getAllItemKeys(object) {
+  var parentKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var keys = [];
+
+  for (var key in object) {
+    if (object.hasOwnProperty(key)) {
+      var currentKey = parentKey ? "".concat(parentKey, ".").concat(key) : key;
+
+      if (_typeof(object[key]) === 'object' && object[key] !== null) {
+        keys = keys.concat(getAllItemKeys(object[key], currentKey));
+      } else {
+        keys.push(currentKey);
+      }
+    }
+  }
+
+  return keys;
+}