[
{
"path": ".editorconfig",
"content": "root = true\n\n[*]\nend_of_line = lf\ninsert_final_newline = true\ntrim_trailing_whitespace = true\ncharset = utf-8\nindent_style = space\nindent_size = 2\n"
},
{
"path": ".github/ISSUE_TEMPLATE.md",
"content": "\n\n## I'm submitting a...\n\n\n[ ] Regression (a behavior that used to work and stopped working in a new release)\n[ ] Bug report \n[ ] Feature request\n[ ] Documentation issue or request\n[ ] Support request => Please do not submit support request here, instead see https://github.com/LokiJS-Forge/LokiDB/blob/master/CONTRIBUTING.md#question\n\nLokiDB version: X.Y.Z\n\n\nBrowser/Node version: Browser X.Y.Z.\n\nOthers:\n\n(): \n\n\n\n\n```\n\nThe **header** is mandatory and the **scope** of the header is optional.\n\nAny line of the commit message cannot be longer 100 characters! This allows the message to be easier\nto read on GitHub as well as in various git tools.\n\nFooter should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.\n\nSamples: (even more [samples][commits])\n\n```\ndocs(changelog): update change log to beta.5\n```\n```\nfix(release): need to depend on latest rxjs and zone.js\n\nThe version in our package.json gets copied to the one we publish, and users need the latest of these.\n```\n\n### Revert\nIf the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body it should say: `This reverts commit .`, where the hash is the SHA of the commit being reverted.\n\n### Type\nMust be one of the following:\n\n* **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)\n* **ci**: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)\n* **docs**: Documentation only changes\n* **feat**: A new feature\n* **fix**: A bug fix\n* **perf**: A code change that improves performance\n* **refactor**: A code change that neither fixes a bug nor adds a feature\n* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)\n* **test**: Adding missing tests or correcting existing tests\n\n### Scope\nThe scope should be the name of the npm package affected (as perceived by person reading changelog generated from commit messages.\n\nThe following is the list of supported scopes:\n\n* **loki**: The LokiDB database.\n* **partitioning-adapter**: The partitioning adapter.\n* **local-storage**: The local storage adapter.\n* **indexed-storage**: The indexed db storage adapter.\n* **fs-storage**: The file system storage adapter.\n* **memory-storage**: The in-memory storage adapter.\n* **full-text-search**: The full-text search engine.\n* **full-text-search-language**: The language analyzer utility package.\n* **full-text-search-language-de**: The german language analyzer.\n* **full-text-search-language-en**: The english language analyzer.\n\nThere are currently a few exceptions to the \"use package name\" rule:\n\n* **packaging**: used for changes that change the npm package layout in all of our packages, e.g. public path changes, package.json changes done to all packages, d.ts file/format changes, changes to bundles, etc.\n* none/empty string: useful for `style`, `test` and `refactor` changes that are done across all packages (e.g. `style: add missing semicolons`)\n\n### Subject\nThe subject contains succinct description of the change:\n\n* use the imperative, present tense: \"change\" not \"changed\" nor \"changes\"\n* don't capitalize first letter\n* no dot (.) at the end\n\n### Body\nJust as in the **subject**, use the imperative, present tense: \"change\" not \"changed\" nor \"changes\".\nThe body should include the motivation for the change and contrast this with previous behavior.\n\n### Footer\nThe footer should contain any information about **Breaking Changes** and is also the place to\nreference GitHub issues that this commit **Closes**.\n\n**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.\n\n[coc]: https://github.com/LokiJS-Forge/LokiDB/blob/master/CODE_OF_CONDUCT.md\n[dev-doc]: https://github.com/LokiJS-Forge/LokiDB/blob/master/DEVELOPER.md\n[github]: https://github.com/LokiJS-Forge/LokiDB\n[new-issue]: https://github.com/LokiJS-Forge/LokiDB/issues/new\n[pulls]: https://github.com/LokiJS-Forge/LokiDB/pulls\n[commit]: https://github.com/LokiJS-Forge/LokiDB/commits/master\n[gitter]: https://gitter.im/techfort/LokiDB\n[plunker]: http://plnkr.co/edit\n[stackoverflow]: http://stackoverflow.com/questions/tagged/lokidb?sort=newest\n"
},
{
"path": "DEVELOPER.md",
"content": "\n\n# Building and testing LokiDB\n\nThis document describes how to set up your development environment to build and test LokiDB.\n\n* [Prerequisite software](#prerequisite-software)\n* [Running tests](#running-tests)\n* [Formatting your source code](#formatting-your-source-code)\n* [Building LokiDB](#building-lokidb)\n\nSee the [contribution guidelines][contribution] if you'd like to contribute to LokiDB.\n\n## Prerequisite software\n\nBefore you can build and test LokiDB, you must install and configure the\nfollowing products on your development machine:\n\n* [Git](http://git-scm.com) and/or the **GitHub app** (for [Mac](http://mac.github.com) or\n [Windows](http://windows.github.com)); [GitHub's Guide to Installing\n Git](https://help.github.com/articles/set-up-git) is a good source of information.\n\n* [Node.js](http://nodejs.org), (version `>=7.0.0`) which is used to run tests and generate distributable files.\n We also use Node's Package Manager, `npm`(version `>=4.0.0`), which comes with Node.\n Depending on your system, you can install Node either from source or as a pre-packaged bundle.\n\n* [Elasticsearch](https://www.elastic.co/downloads/elasticsearch) which is used to unit test LokiDB's full text search.\n\n## Running tests\n\nTo run tests:\n\n```shell\n$ npm run test # Run all LokiDB tests\n\n$ npm run test:web # Run tests only in web browser\n$ npm run test:node # Run tests only in node\n```\n\nAll the tests are executed on our Continuous Integration infrastructure and a PR could only be merged once the tests pass.\n\n## Formatting your source code\n\nLokiDB uses [ESLint][eslint] to format the source code. If the source code is not properly formatted, the CI will fail and the PR can not be merged.\n\nYou can check that your code is properly formatted and adheres to coding style by running:\n\n``` shell\n$ npm run lint\n```\n\nYou can automatically format your code by running:\n\n``` shell\n$ npm run lint:fix\n```\n\n## Building LokiDB\n\nTo build LokiDB, run:\n\n``` shell\n$ npm run build\n```\n\n[eslint]: https://eslint.org/\n[contribution]: https://github.com/LokiJS-Forge/LokiDB/blob/master/CONTRIBUTING.md\n"
},
{
"path": "LICENSE",
"content": "This text consists of three parts:\n\nPart I: Remarks regarding the license given in\nPart II: MIT License\nPart III: Apache License\n\n-------------------------------------------------------------------------------\nPart I:\n\nLokiDB is mostly distributed under the MIT License.\n\nExcept the following packages:\n\n@lokidb/full-text-search\n - Apache License (https://lucene.apache.org/)\n - Apache License (https://www.elastic.co/)\n\n-------------------------------------------------------------------------------\nPart II:\n\n MIT License\n\n Copyright (c) 2015-2018 Joe Minichino \n David Easterday \n Toni Neubert \n\n Permission is hereby granted, free of charge, to any person obtaining a\n copy of this software and associated documentation files (the \"Software\"),\n to deal in the Software without restriction, including without limitation\n the rights to use, copy, modify, merge, publish, distribute, sublicense,\n and/or sell copies of the Software, and to permit persons to whom the\n Software is furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included in\n all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\n\n-------------------------------------------------------------------------------\nPart III:\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n"
},
{
"path": "README.md",
"content": "[![npm status][npm]][npm-url]\n[![build status][build]][build-url]\n[![coverage status][coverage]][coverage-url]\n\n# LokiDB\n\nLokiDB is a document oriented database written in TypeScript.\n\nIts purpose is to store javascript objects as documents in a blazing fast nosql fashion and retrieve them with a similar mechanism.\n\nLokiDB is the official successor of [LokiJS][lokijs-url].\n\n## Install\n\nInstall with npm:\n\n```bash\nnpm install @lokidb/loki\n```\n\n## Documentation\n\nCheck out our interactive [documentation](https://LokiJS-Forge.github.io/LokiDB/).\n\n## Plugins\n\n### Storage and Adapter\n\n|Name|Description|\n|:---|:----------|\n|[@lokidb/fs-storage][fs-storage-npm-url] | A persistence adapter which persists to node fs module storage. |\n|[@lokidb/local-storage][local-storage-npm-url] | A persistence adapter which persists to web browser's local storage. |\n|[@lokidb/indexed-storage][indexed-storage-npm-url] | A persistence adapter which persists to web browser's indexed db storage. |\n|[@lokidb/memory-storage][memory-storage-npm-url] | A persistence adapter which persists to memory. |\n|[@lokidb/partitioning-adapter][partitioning-adapter-npm-url] | An adapter for adapters. Converts a non reference mode adapter into a reference mode adapter which can perform destructuring and partitioning.|\n\n### Full-Text Search\n\n|Name|Description|\n|:---|:----------|\n|[@lokidb/full-text-search][full-text-search-npm-url] | A full-text search engine. |\n|[@lokidb/full-text-search-language][full-text-search-language-npm-url] | A language analyzer utility package. |\n|[@lokidb/full-text-search-language-de][full-text-search-language-de-npm-url] | ![flag][full-text-search-language-de-flag] A german language analyzer. |\n|[@lokidb/full-text-search-language-en][full-text-search-language-en-npm-url] | ![flag][full-text-search-language-en-flag] An english language analyzer. |\n\n[build]: https://travis-ci.org/LokiJS-Forge/LokiDB.svg?branch=master\n[build-url]: https://travis-ci.org/LokiJS-Forge/LokiDB\n[coverage]: https://codecov.io/gh/LokiJS-Forge/LokiDB/branch/master/graph/badge.svg\n[coverage-url]: https://codecov.io/gh/LokiJS-Forge/LokiDB/branch/master\n\n[lokijs-url]: https://github.com/techfort/LokiJS\n\n[npm]: https://img.shields.io/npm/v/@lokidb/loki.svg\n[npm-url]: https://www.npmjs.com/package/@lokidb/loki\n\n[fs-storage]: https://github.com/LokiJS-Forge/LokiDB\n[fs-storage-npm-url]: https://www.npmjs.com/package/@lokidb/fs-storage\n\n[local-storage]: https://github.com/LokiJS-Forge/LokiDB\n[local-storage-npm-url]: https://www.npmjs.com/package/@lokidb/local-storage\n\n[indexed-storage]: https://github.com/LokiJS-Forge/LokiDB\n[indexed-storage-npm-url]: https://www.npmjs.com/package/@lokidb/indexed-storage\n\n[memory-storage]: https://github.com/LokiJS-Forge/LokiDB\n[memory-storage-npm-url]: https://www.npmjs.com/package/@lokidb/memory-storage\n\n[partitioning-adapter]: https://github.com/LokiJS-Forge/LokiDB\n[partitioning-adapter-npm-url]: https://www.npmjs.com/package/@lokidb/partitioning-adapter\n\n[full-text-search]: https://github.com/LokiJS-Forge/LokiDB\n[full-text-search-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search\n[full-text-search-language]: https://github.com/LokiJS-Forge/LokiDB\n[full-text-search-language-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search-language\n[full-text-search-language-de]: https://github.com/LokiJS-Forge/LokiDB\n[full-text-search-language-de-flag]: https://raw.githubusercontent.com/stevenrskelton/flag-icon/master/png/16/country-4x3/de.png\n[full-text-search-language-de-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search-language-de\n[full-text-search-language-en]: https://github.com/LokiJS-Forge/LokiDB\n[full-text-search-language-en-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search-language-en\n[full-text-search-language-en-flag]: https://raw.githubusercontent.com/stevenrskelton/flag-icon/master/png/16/country-4x3/us.png\n"
},
{
"path": "benchmark/benchmark.js",
"content": "/**\n * Core, \"single object lookup\" benchmarks\n */\n\nlet Loki = require('../build/packages/loki/lokidb.loki.js').default,\n crypto = require(\"crypto\");\n\n/**\n * Generates a random string using node crypto library which is less memory 'leaky'\n */\nfunction genRandomVal() {\n return crypto.randomBytes(50).toString('hex');\n}\n\n/**\n * Helper method for instantiating a loki database\n * @param {*} mode \n */\nfunction createDatabase(mode) {\n let tdb = new Loki(\"temp.db\");\n let coll;\n\n switch (mode) {\n case \"avl\":\n coll = tdb.addCollection('perfcoll', {\n rangedIndexes: {\n \"customId\": { indexTypeName: \"avl\", comparatorName: \"js\" }\n }\n });\n break;\n case \"unique\":\n coll = tdb.addCollection('perfcoll', {\n unique: ['customId']\n });\n break;\n case \"none\":\n default:\n coll = tdb.addCollection('perfcoll');\n break;\n }\n\n return tdb;\n}\n\n/**\n * Helper method for populating a collection\n * @param {*} db \n * @param {*} count \n */\nfunction populateDatabase(db, count) {\n let coll = db.getCollection(\"perfcoll\");\n\n // populate collection\n let idxbuf = [];\n let customIdx, v1;\n for (let idx = 0; idx < count; idx++) {\n customIdx = count - idx;\n\n idxbuf.push(customIdx);\n v1 = genRandomVal();\n\n coll.insert({\n customId: customIdx,\n val: v1,\n val2: \"more data 1234567890\"\n });\n }\n\n return idxbuf;\n}\n\n/**\n * Benchmarks collection.by() performance with unique index\n * @param {*} count \n * @param {*} multiple \n */\nfunction benchUniquePerf(count, multiple) {\n let udb = createDatabase(\"unique\");\n let uniquecoll = udb.getCollection('perfcoll');\n\n let v1, idxbuf = [];\n\n for (let idx = 0; idx < count; idx++) {\n v1 = genRandomVal();\n\n uniquecoll.insert({\n customId: (count - idx),\n val: v1,\n val2: \"more data 1234567890\"\n });\n\n idxbuf.push(count - idx);\n }\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0.0;\n\n let customIdx, result;\n\n for (let m = 0; m < multiple; m++) {\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf[idx];\n\n start = process.hrtime();\n result = uniquecoll.by('customId', customIdx);\n end = process.hrtime(start);\n totalTimes.push(end);\n\n if (result.customId !== customIdx) {\n console.log(\"(perfUnique) object retrieved does match custom id\");\n }\n }\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = multiple * count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"coll.by() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + multiple*count + \" iterations, \" + count + \" docs x \" + multiple);\n};\n\n/**\n * Benchmarks collection.get() performance\n * @param {*} count number of documents to insert into collection\n * @param {*} multiple number of times to repeat get() for each document\n */\nfunction testperfGet(count, multiple) {\n let gdb = createDatabase(\"none\");\n let coll = gdb.getCollection('perfcoll');\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0.0;\n\n let customIdx, v1, obj = {}, idxbuf = [];\n\n for (let idx = 0; idx < count; idx++) {\n v1 = genRandomVal();\n\n obj = coll.insert({\n customId: (count - idx),\n val: v1,\n val2: \"more data 1234567890\"\n });\n\n idxbuf.push(obj.$loki);\n }\n\n let result;\n\n for (let m = 0; m < multiple; m++) {\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf[idx];\n\n start = process.hrtime();\n result = coll.get(customIdx);\n end = process.hrtime(start);\n totalTimes.push(end);\n\n if (result.$loki !== customIdx) {\n console.log(\"(perfGet) object retrieved does match get id\");\n }\n }\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = multiple * count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"coll.get() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + multiple*count + \" iterations, \" + count + \" docs x \" + multiple);\n}\n\n/**\n * Benchmark collection find() performance\n * @param {*} mode Index Mode (\"none\", \"unique\", \"avl\")\n * @param {*} count Document count to populate collection with\n * @param {*} multiple Used to repeat finding each document this number of times\n */\nfunction testperfFind(mode, count, multiple) {\n multiple = multiple || 1;\n\n let fdb = createDatabase(mode);\n let idxbuf = populateDatabase(fdb, count);\n let coll = fdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n let results;\n\n for (let m = 0; m < multiple; m++) {\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf[idx];\n \n start = process.hrtime();\n results = coll.find({\n 'customId': customIdx\n });\n end = process.hrtime(start);\n totalTimes.push(end);\n \n if (results.length !== 1) {\n console.log(\"(perfFind) received \" + results.length + \"instead of 1 matches!\");\n }\n }\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = multiple * count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"coll.find() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + multiple * count + \" iterations, \" + count + \" docs x \" + multiple);\n}\n\n/**\n * Resultset benchmark\n * @param {*} mode \n * @param {*} count \n */\nfunction testperfRS(mode, count, multiple) {\n multiple = multiple || 1;\n\n let rsdb = createDatabase(mode);\n let idxbuf = populateDatabase(rsdb, count);\n let coll = rsdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n let customIdx, results;\n\n for (let m = 0; m < multiple; m++) {\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf[idx];\n \n start = process.hrtime();\n results = coll.chain().find({\n 'customId': customIdx\n }).data();\n end = process.hrtime(start)\n totalTimes.push(end);\n \n if (results.length !== 1) {\n console.log(\"(perfRS) received \" + results.length + \"instead of 1 matches!\");\n }\n }\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = multiple * count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"resultset chained find() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + multiple * count + \" iterations, \" + count + \" docs x \" + multiple);\n}\n\n/**\n * Benchmark dynamic view performance\n * @param {*} mode \n * @param {*} count \n * @param {*} multiple \n */\nfunction testperfDV(mode, count, multiple) {\n multiple = multiple || 1;\n \n let dvdb = createDatabase(mode);\n let idxbuf = populateDatabase(dvdb, count);\n let coll = dvdb.getCollection(\"perfcoll\");\n\n let start, end;\n let start2, end2, totalTime2 = 0.0;\n let totalTimes = [];\n let totalTimes2 = [];\n let totalMS = 0;\n let totalMS2 = 0;\n\n let customIdx, dv, results;\n\n for (let m = 0; m < multiple; m++) {\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf[idx];\n \n start = process.hrtime();\n dv = coll.addDynamicView(\"perfview\");\n dv.applyFind({\n 'customId': customIdx\n });\n results = dv.data();\n end = process.hrtime(start);\n totalTimes.push(end);\n \n // test speed of repeated query on an already set up dynamicview\n start2 = process.hrtime();\n results = dv.data();\n end2 = process.hrtime(start2);\n totalTimes2.push(end2);\n \n coll.removeDynamicView(\"perfview\");\n }\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n totalMS2 += totalTimes2[idx][0] * 1e3 + totalTimes2[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n totalMS2 = totalMS2.toFixed(2);\n let rate = multiple * count * 1000 / totalMS;\n let rate2 = multiple * count * 1000 / totalMS2;\n rate = rate.toFixed(2);\n rate2 = rate2.toFixed(2);\n\n console.log(\"loki dynamic view first find : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + multiple * count + \" iterations, \" + count + \" docs x \" + multiple);\n console.log(\"loki dynamic view subsequent finds : \" + totalMS2 + \"ms (\" + rate2 + \" ops/s) \" + multiple * count + \" iterations, \" + count + \" docs x \" + multiple);\n}\n\n/**\n * Attempt to free up global variables and invoke node garbage collector (if enabled)\n */\nfunction cleanup() {\n if (global.gc) {\n global.gc()\n }\n}\n\nlet corePerf = [\n () => testperfGet(200000, 20),\n () => benchUniquePerf(200000, 20)\n];\n\nlet nonIndexedSteps = [\n () => testperfFind(\"none\", 5000, 8),\n () => testperfRS(\"none\", 5000, 8),\n () => testperfDV(\"none\", 5000, 8)\n];\n\nlet nonIndexedStepsHigh = [\n () => testperfFind(\"none\", 10000, 1),\n () => testperfRS(\"none\", 10000, 1),\n () => testperfDV(\"none\", 10000, 1)\n];\n\nlet avlIndexSteps = [\n () => testperfFind(\"avl\", 20000, 20),\n () => testperfRS(\"avl\", 20000, 20),\n () => testperfDV(\"avl\", 20000, 20)\n];\n\nlet avlIndexStepsHigh = [\n () => testperfFind(\"avl\", 200000, 2),\n () => testperfRS(\"avl\", 200000, 2),\n () => testperfDV(\"avl\", 200000, 2)\n];\n\nlet perfGroups = [\n { name: \"Benchmarking Core Id lookup performance\", steps: corePerf },\n { name: \"Benchmarking NON-INDEX query performance (Lower doc count)\", steps: nonIndexedSteps },\n { name: \"Benchmarking NON-INDEX query performance (Higher doc count)\", steps: nonIndexedStepsHigh },\n { name: \"Benchmarking AVL TREE INDEX query performance (Lower doc count)\", steps: avlIndexSteps },\n { name: \"Benchmarking AVL TREE INDEX query performance (Higher doc count)\", steps: avlIndexStepsHigh }\n];\n\n/**\n * Executes steps within a benchmark group, pausing in between steps.\n * Once the benchmark group steps are depleted, we initiate next group.\n * @param {*} steps \n */\nfunction execSteps(steps) {\n // if we are finished with this group's steps...\n if (steps.length === 0) {\n // wait a few seconds in between benchmark groups\n setTimeout(execGroups, 4000);\n return;\n }\n\n let s = steps.shift();\n\n s();\n\n setTimeout(() => { execSteps(steps); }, 1000);\n}\n\n/**\n * Kicks off a group of benchmarks, cleaning up in between\n */\nfunction execGroups() {\n let g = perfGroups.shift();\n if (!g) return;\n\n cleanup();\n\n console.log(\"\");\n console.log(\"## \" + g.name + \" ##\");\n console.log(\"\");\n execSteps(g.steps);\n}\n\nconsole.log(\"\");\nconsole.log(\"Note: run 'npm run build' before benchmarking after getting latest or modifying code\");\nconsole.log(\"\");\n\nif (!global.gc) {\n console.warn(\"##\");\n console.warn(\"## IMPORTANT! : For accuracy of results, launch node with --expose-gc flag\");\n console.warn(\"##\");\n}\n\nexecGroups();"
},
{
"path": "benchmark/benchmark_indexes.js",
"content": "/**\n * This module is to be used to benchmark loki binary index lifecycle\n *\n * Attempt to simulate and benchmark effects of various rebuild strategies on\n * insert, find, remove, and update to be used to instrument refactorings/optimizations.\n *\n * Since a given index type may prioritize lookups/finds over maintenance of insert/update/remove ops,\n * the 'Nightmare' tests attempt to pair a find along with insert/update/removes. The resulting\n * times tend to average out this bias to allow examining overall performance for scale.\n * \n * Currently, this benchmark will compare the following index options :\n * - Unindexed\n * - Adaptive Binary Indices (Lazy benchmarks can be uncommented if you wish those as well)\n * - AVL Indexes based on self-balancing AVL binary search trees \n */\n\n\nlet Loki = require('../build/packages/loki/lokidb.loki.js').default,\n crypto = require(\"crypto\"); // for less 'leaky' random string generation\n\n/**\n * Generate random string using node cryto lib for less memory 'leaky' behavior than js string construction\n */\nfunction genRandomVal() {\n return crypto.randomBytes(50).toString('hex');\n}\n\n/**\n * Helper method to shuffle array\n * @param {*} array \n */\nfunction shuffle(array) {\n let currentIndex = array.length, temporaryValue, randomIndex;\n\n // While there remain elements to shuffle...\n while (0 !== currentIndex) {\n\n // Pick a remaining element...\n randomIndex = Math.floor(Math.random() * currentIndex);\n currentIndex -= 1;\n\n // And swap it with the current element.\n temporaryValue = array[currentIndex];\n array[currentIndex] = array[randomIndex];\n array[randomIndex] = temporaryValue;\n }\n\n return array;\n};\n\n/**\n * Helper method to convert number of bytes into more readable representation.\n * @param {*} bytes \n * @param {*} decimals \n */\nfunction formatBytes(bytes, decimals) {\n if (bytes == 0) return '0 Byte';\n let k = 1000; // or 1024 for binary\n let dm = decimals + 1 || 3;\n let sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\n let i = Math.floor(Math.log(bytes) / Math.log(k));\n return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];\n}\n\n/**\n * Logs memory usage info to console\n * @param {*} msg \n */\nfunction logMemoryUsage(msg) {\n let pmu = process.memoryUsage();\n console.log(msg + \" => rss : \" + formatBytes(pmu.rss) + \" heapTotal : \" + formatBytes(pmu.heapTotal) + \" heapUsed : \" + formatBytes(pmu.heapUsed));\n}\n\n/**\n * Helper method for instantiating a loki database\n * @param {*} mode indexing mode (\"none\", \"avl\")\n */\nfunction createDatabase(mode) {\n let tdb = new Loki(\"temp.db\");\n let coll;\n\n switch (mode) {\n case \"avl\":\n coll = tdb.addCollection('perfcoll', {\n rangedIndexes: {\n \"customId\": { indexTypeName: \"avl\", comparatorName: \"js\" }\n }\n });\n break;\n case \"none\":\n default:\n coll = tdb.addCollection('perfcoll');\n break;\n }\n\n return tdb;\n}\n\n/**\n * Helper method for populating a collection\n * @param {*} db loki database instance containing collection to populate\n * @param {*} count number of documents to insert\n */\nfunction populateDatabase(db, count) {\n let coll = db.getCollection(\"perfcoll\");\n\n // populate collection\n let idxbuf = [];\n let customIdx, v1;\n for (let idx = 0; idx < count; idx++) {\n customIdx = count - idx;\n\n idxbuf.push(customIdx);\n v1 = genRandomVal();\n\n coll.insert({\n customId: customIdx,\n val: v1,\n val2: \"more data 1234567890\"\n });\n }\n\n return idxbuf;\n}\n\n/**\n * Profiles memory usage for unindexed and avl indexed collections\n * @param {*} mode indexing mode (\"none\", \"avl\") \n * @param {*} count \n */\nfunction profileDatabaseMemory(mode, count) {\n let mdb = createDatabase(mode);\n populateDatabase(mdb, count);\n let coll = mdb.getCollection(\"perfcoll\");\n\n let id, v1;\n\n for (let idx = 0; idx < 100000; idx++) {\n id = count - idx;\n v1 = genRandomVal();\n\n coll.insert({\n customId: id,\n val1: v1,\n val2: \"more data 1234567890\"\n });\n }\n\n logMemoryUsage(mode);\n}\n\n/**\n * Benchmarks insertion rates for unindexed and avl indexed collections\n * @param {*} mode indexing mode (\"none\", \"avl\") \n * @param {*} count \n */\nfunction profileInsertion(mode, count) {\n let mdb = createDatabase(mode);\n let coll = mdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n // populate collection manually instead of helper since we won't retain idxbuf\n let customIdx, v1;\n for (let idx = 0; idx < count; idx++) {\n customIdx = count - idx;\n\n v1 = genRandomVal();\n\n start = process.hrtime();\n\n coll.insert({\n customId: customIdx,\n val: v1,\n val2: \"more data 1234567890\"\n });\n\n end = process.hrtime(start);\n totalTimes.push(end);\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"insertion rate (\" + mode + \") : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + count + \" documents\");\n}\n\n/**\n * Benchmarks find performance for given document count (not multiplied to show raw ms perf)\n * @param {*} mode indexing mode (\"none\", \"avl\")\n * @param {*} count \n */\nfunction perfFind(mode, count) {\n let fdb = createDatabase(mode);\n let idxbuf = populateDatabase(fdb, count);\n let coll = fdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n let customIdx, results;\n\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf[idx];\n\n start = process.hrtime();\n results = coll.find({\n 'customId': customIdx\n });\n end = process.hrtime(start);\n totalTimes.push(end);\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"random coll.find() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + count + \" iterations\");\n}\n\n/**\n * Benchmarks interlacing insert + find (on indexed column) to measure index thrashing\n * @param {*} mode indexing mode (\"none\", \"avl\")\n * @param {*} count \n */\nfunction perfFindInterlacedInserts(mode, count) {\n let fdb = createDatabase(mode);\n let idxbuf = [];\n let coll = fdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n let customIdx, results;\n\n for (let idx = 0; idx < count; idx++) {\n customIdx = count - idx;\n\n start = process.hrtime();\n\n // insert record with id outside range of pre-populated records\n coll.insert({\n customId: customIdx,\n val: 999,\n val2: 999,\n val3: \"more data 1234567890\"\n });\n\n // do quick find of object just inserted\n results = coll.find({\n 'customId': customIdx\n });\n\n end = process.hrtime(start);\n totalTimes.push(end);\n\n if (results.length !== 1 || results[0].customId !== customIdx) {\n console.log(\"(interlaced inserts) unexpected results\")\n }\n }\n\n if (coll.find().length !== count) {\n console.log(\"(interlaced inserts) unexpected total inserted document count\");\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"interlaced inserts + coll.find() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + count + \" iterations\");\n}\n\n/**\n * Benchmarks interlacing find + remove (on indexed column) to measure index thrashing\n * @param {*} mode indexing mode (\"none\", \"avl\")\n * @param {*} count\n */\nfunction perfFindInterlacedRemoves(mode, count, multiple) {\n let fdb = createDatabase(mode);\n let idxbuf = populateDatabase(fdb, count);\n let coll = fdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n let removeId, result;\n\n for (let idx = 0; idx < count; idx++) {\n removeId = idxbuf.pop();\n\n start = process.hrtime();\n result = coll.findOne({\n 'customId': removeId\n });\n coll.remove(result);\n\n end = process.hrtime(start);\n totalTimes.push(end);\n }\n\n if (coll.find().length !== 0) {\n console.log(\"(interlaces removes) unexpected final doc count\");\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"interlaced removes + coll.find() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + count + \" iterations\");\n}\n\n/**\n * Benchmarks interlacing find + update (on indexed column) to measure index thrashing\n * @param {*} mode indexing mode (\"none\", \"avl\")\n * @param {*} count number of interlaced finds+updates to perform\n */\nfunction perfFindInterlacesUpdates(mode, count) {\n let fdb = createDatabase(mode);\n let idxbuf = populateDatabase(fdb, count);\n let coll = fdb.getCollection(\"perfcoll\");\n\n let start, end;\n let totalTimes = [];\n let totalMS = 0;\n\n let customIdx, newIdx, result;\n\n for (let idx = 0; idx < count; idx++) {\n customIdx = idxbuf.pop();\n newIdx = count + idx;\n\n start = process.hrtime();\n\n // lookup next doc\n result = coll.findOne({\n 'customId': customIdx\n });\n\n // update doc, modifying the field (potentially) being indexed\n result.customId = newIdx;\n coll.update(result);\n\n end = process.hrtime(start);\n totalTimes.push(end);\n }\n\n if (coll.find().length !== count) {\n console.log(\"(interlaced updates) unexpected final doc count\");\n }\n\n for (let idx = 0; idx < totalTimes.length; idx++) {\n totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;\n }\n\n totalMS = totalMS.toFixed(2);\n let rate = count * 1000 / totalMS;\n rate = rate.toFixed(2);\n console.log(\"interlaced updates + coll.find() : \" + totalMS + \"ms (\" + rate + \" ops/s) \" + count + \" iterations\");\n}\n\n/**\n * Attempt to free up global variables and invoke node garbage collector (if enabled)\n */\nfunction cleanup() {\n if (global.gc) {\n global.gc();\n }\n}\n\nlet memoryProfileSteps = [\n cleanup,\n () => logMemoryUsage(\"baseline\"),\n () => profileDatabaseMemory(\"unindexed\", 10000),\n cleanup,\n () => logMemoryUsage(\"baseline\"),\n () => profileDatabaseMemory(\"avl\", 10000)\n];\n\nlet insertionProfileSteps = [\n // Unindexed Inserts\n cleanup,\n () => console.log(\"no index\"),\n () => profileInsertion(\"none\", 100000),\n // AVL indexed inserts\n cleanup,\n () => console.log(\"avl tree index\"),\n () => profileInsertion(\"avl\", 100000)\n];\n\nlet nightmareUnindexedLowSteps = [\n () => {\n console.log(\"\");\n console.log(\"------------ Beginning Nightmare Benchmarks ------------\");\n console.log(\"Nightmare tests combine a find() with either an insert(), update(), or remove()\");\n console.log(\"to remove any bias and show weaknesses that each indexing strategy may be leveraging, \");\n console.log(\"such as placing all emphasis on find() performance to detriment of index maintenance costs.\");\n console.log(\"\");\n },\n () => {\n console.log(\"Perf: Unindexed Nightmare (Lower Scale @ 5,000 docs/iterations) ------------------------\");\n createDatabase(\"none\");\n },\n cleanup,\n () => perfFind(\"none\", 5000),\n cleanup,\n () => perfFindInterlacedInserts(\"none\", 5000),\n cleanup,\n () => perfFindInterlacedRemoves(\"none\", 5000),\n cleanup,\n () => perfFindInterlacesUpdates(\"none\", 5000)\n];\n\nlet nightmareUnindexedHighSteps = [\n () => {\n console.log(\"Perf: Unindexed Nightmare (Higher Scale @ 10,000 docs/iterations) ------------------------\");\n createDatabase(\"none\");\n },\n cleanup,\n () => perfFind(\"none\", 10000),\n cleanup,\n () => perfFindInterlacedInserts(\"none\", 10000),\n cleanup,\n () => perfFindInterlacedRemoves(\"none\", 10000),\n cleanup,\n () => perfFindInterlacesUpdates(\"none\", 10000),\n];\n\nlet nightmareAvlLowSteps = [\n () => console.log(\"Perf: AVL Indexed Nightmare (Lower Scale @ 40,000 docs/iterations) ---\"),\n cleanup,\n () => perfFind(\"avl\", 40000),\n cleanup,\n () => perfFindInterlacedInserts(\"avl\", 40000),\n cleanup,\n () => perfFindInterlacedRemoves(\"avl\", 40000),\n cleanup,\n () => perfFindInterlacesUpdates(\"avl\", 40000),\n];\n\nlet nightmareAvlHighSteps = [\n () => console.log(\"Perf: AVL Indexed Nightmare (Higher Scale @ 100,000 docs/iterations) ---\"),\n cleanup,\n () => perfFind(\"avl\", 100000),\n cleanup,\n () => perfFindInterlacedInserts(\"avl\", 100000),\n cleanup,\n () => perfFindInterlacedRemoves(\"avl\", 100000),\n cleanup,\n () => perfFindInterlacesUpdates(\"avl\", 100000)\n];\n\nlet perfGroups = [\n //{ name: \"Memory Profiling of database with various indexing\", steps: memoryProfileSteps },\n //{ name: \"Document Insertion rates with various indexes\", steps: insertionProfileSteps },\n { name: \"Nightmare Unindexed (Low Range)\", steps: nightmareUnindexedLowSteps },\n { name: \"Nightmare Unindexed (High Range)\", steps: nightmareUnindexedHighSteps },\n { name: \"Nightmare AVL Index (Low Range)\", steps: nightmareAvlLowSteps },\n { name: \"Nightmare AVL Index (High Range)\", steps: nightmareAvlHighSteps }\n];\n\nfunction execSteps(steps) {\n if (steps.length === 0) {\n setTimeout(execGroups, 4000);\n return;\n }\n\n let s = steps.shift();\n\n s();\n\n setTimeout(() => { execSteps(steps); }, 1000);\n}\n\nfunction execGroups() {\n let g = perfGroups.shift();\n if (!g) return;\n\n cleanup();\n\n console.log(\"\");\n console.log(\"## \" + g.name + \" ##\");\n console.log(\"\");\n execSteps(g.steps);\n}\n\nif (!global.gc) {\n console.warn(\"##\");\n console.warn(\"## IMPORTANT! : For accuracy of results, launch node with --expose-gc flag\");\n console.warn(\"##\");\n}\n\nconsole.log(\"\");\nconsole.log(\"Note: run 'npm run build' before benchmarking after getting latest or modifying code\");\nconsole.log(\"\");\n\nexecGroups();"
},
{
"path": "config/jasmine.json",
"content": "{\n \"spec_dir\": \"packages/*/spec\",\n \"spec_files\": [\n \"generic/**/*.spec.[jt]s\",\n \"node/**/*.spec.[jt]s\"\n ],\n \"helpers\": [\n \"../../../node_modules/ts-node/register/index.js\",\n \"../../../node_modules/jasmine-expect/index.js\",\n \"../../common/spec/helper/**/*helper.[jt]s\",\n \"helper/**/*.[jt]s\"\n ],\n \"stopSpecOnExpectationFailure\": false,\n \"random\": false\n}\n"
},
{
"path": "config/karma.config.js",
"content": "/* global process, require, module, require */\nconst path = require(\"path\");\n\nmodule.exports = function (config) {\n const configuration = {\n frameworks: [\"jasmine\", \"jasmine-matchers\"],\n browsers: [\"ChromeHeadless\"],\n basePath: \"../\",\n files: [\n {pattern: \"packages/*/spec/generic/**/*.spec.ts\", watched: false},\n {pattern: \"packages/*/spec/web/**/*.spec.ts\", watched: false}\n ],\n preprocessors: {\n \"packages/*/spec/generic/**/*.spec.ts\": [\"webpack\"],\n \"packages/*/spec/web/**/*.spec.ts\": [\"webpack\"]\n },\n // coverage reporter generates the coverage\n reporters: [\"progress\", \"coverage-istanbul\"],\n coverageIstanbulReporter: {\n dir: \"coverage/karma/\",\n reports: [\"text-summary\", \"json\"],\n fixWebpackSourcePaths: true\n },\n mime: {\n \"text/x-typescript\": [\"ts\"]\n },\n webpack: {\n mode: \"development\",\n stats: 'errors-only',\n resolve: {\n extensions: [\".ts\"],\n },\n devtool: \"source-map\",\n module: {\n rules: [\n {\n enforce: \"pre\",\n test: /\\.ts$/,\n loader: \"tslint-loader\",\n exclude: /node_modules/,\n options: {\n failOnHint: false,\n configFile: path.join(__dirname, \"tslint.json\"),\n }\n },\n {\n test: /\\.ts$/,\n loader: \"ts-loader\",\n options: {\n configFile: path.join(__dirname, \"tsconfig.webpack.json\")\n }\n },\n {\n enforce: \"post\",\n exclude: [\n /node_modules/,\n /\\.spec\\.ts$/,\n /.*\\/spec\\/.+\\.ts/,\n /\\.helper\\.ts$/,\n /.*\\/helper\\/.+\\.ts/\n ],\n loader: \"istanbul-instrumenter-loader?esModules=true\",\n test: /\\.ts$/\n }\n ]\n }\n },\n webpackMiddleware: {\n logLevel: \"warn\"\n },\n plugins: [\n \"karma-chrome-launcher\",\n \"karma-coverage-istanbul-reporter\",\n \"karma-jasmine\",\n \"karma-jasmine-matchers\",\n \"karma-webpack\",\n ],\n };\n\n config.set(configuration);\n};\n"
},
{
"path": "config/nycrc.json",
"content": "{\n \"reporter\": [\n \"text-summary\",\n \"html\"\n ],\n \"report-dir\": \"./coverage/\",\n \"temp-directory\": \"./coverage/\"\n}\n"
},
{
"path": "config/nycrc.node.json",
"content": "{\n \"extension\": [\n \".ts\"\n ],\n \"reporter\": [\n \"text-summary\",\n \"json\"\n ],\n \"exclude\": [\n \"**/*.helper.[jt]s\",\n \"**/*.spec.[jt]s\",\n \"**/spec/**/*.[jt]s\"\n ],\n \"report-dir\": \"./coverage/node/\"\n}\n"
},
{
"path": "config/tsconfig.tslint.json",
"content": "{\n \"compileOnSave\": false,\n \"compilerOptions\": {\n \"outDir\": \"../types/\",\n \"sourceMap\": true,\n \"declaration\": true,\n \"moduleResolution\": \"classic\",\n \"strictPropertyInitialization\": true,\n \"alwaysStrict\": true,\n \"noImplicitAny\": true,\n \"noImplicitReturns\": true,\n \"noUnusedLocals\": true,\n \"noUnusedParameters\": true,\n \"suppressImplicitAnyIndexErrors\": true,\n \"target\": \"es6\",\n \"lib\": [\n \"es2017\"\n ],\n \"typeRoots\": [\n \"node_modules/@types\"\n ],\n \"types\": [\n \"jasmine\",\n \"jasmine-expect\",\n \"node\"\n ]\n },\n \"include\": [\n \"../packages/**/*.ts\"\n ]\n}\n"
},
{
"path": "config/tsconfig.webpack.json",
"content": "{\n \"compileOnSave\": false,\n \"compilerOptions\": {\n \"outDir\": \"../types/\",\n \"sourceMap\": true,\n \"declaration\": true,\n \"moduleResolution\": \"classic\",\n \"strictPropertyInitialization\": true,\n \"alwaysStrict\": true,\n \"noImplicitAny\": true,\n \"noImplicitReturns\": true,\n \"noUnusedLocals\": true,\n \"noUnusedParameters\": true,\n \"suppressImplicitAnyIndexErrors\": true,\n \"target\": \"es6\",\n \"lib\": [\n \"es2017\",\n \"dom\"\n ],\n \"typeRoots\": [\n \"node_modules/@types\"\n ],\n \"types\": [\n \"jasmine\",\n \"jasmine-expect\",\n \"node\"\n ]\n },\n \"include\": [\n \"../packages/*/src/**/*.ts\"\n ]\n}\n"
},
{
"path": "config/tslint.json",
"content": "{\n \"rulesDirectory\": [\n \"../node_modules/vrsource-tslint-rules/rules\",\n \"../node_modules/tslint-eslint-rules/dist/rules\"\n ],\n \"extends\": [\n \"tslint-eslint-rules\"\n ],\n \"rules\": {\n \"no-console\": [true, \"log\"],\n \"no-duplicate-imports\": true,\n \"no-duplicate-variable\": true,\n \"no-jasmine-focus\": true,\n \"no-var-keyword\": true,\n \"semicolon\": [true],\n \"variable-name\": [true, \"ban-keywords\"],\n \"no-inner-declarations\": [true, \"function\"],\n \"quotemark\": [true, \"double\"],\n \"eofline\": true,\n \"ter-indent\": [true, 2, {\n \"SwitchCase\": 1\n }],\n \"whitespace\": [true, \"check-branch\", \"check-decl\", \"check-operator\", \"check-module\", \"check-separator\",\n \"check-rest-spread\", \"check-type\", \"check-type\", \"check-typecast\", \"check-type-operator\", \"check-preblock\"],\n \"no-trailing-whitespace\": true\n }\n}\n"
},
{
"path": "config/webpack-config-creator.js",
"content": "/* global __dirname, module, require */\nconst path = require(\"path\");\n\nmodule.exports = (options) => {\n if (options.entry === undefined) {\n throw Error(\"options.entry must be specified.\")\n }\n if (options.filename === undefined) {\n throw Error(\"options.Filename must be specified.\")\n }\n if (options.library === undefined) {\n throw Error(\"options.library must be specified.\")\n }\n\n return {\n mode: \"production\",\n entry: options.entry,\n output: {\n filename: options.filename,\n library: options.library,\n libraryTarget: \"umd2\",\n umdNamedDefine: true,\n globalObject: \"typeof self !== 'undefined' ? self : this\"\n },\n externals: options.externals,\n resolve: {\n extensions: [\".ts\"]\n },\n devtool: \"source-map\",\n module: {\n rules: [\n {\n enforce: \"pre\",\n test: /\\.ts$/,\n loader: \"tslint-loader\",\n exclude: /node_modules/,\n options: {\n failOnHint: true,\n configFile: path.join(\"config\", \"tslint.json\"),\n }\n },\n {\n test: /\\.ts$/,\n loader: \"ts-loader\",\n options: {\n configFile: path.join(\"config\", \"tsconfig.webpack.json\")\n }\n }\n ]\n },\n optimization: {\n minimize: false\n },\n };\n};\n"
},
{
"path": "dist/packages/fs-storage/lokidb.fs-storage.js",
"content": "(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"fs\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"@lokidb/fs-storage\", [\"fs\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"@lokidb/fs-storage\"] = factory(require(\"fs\"));\n\telse\n\t\t{ root[\"@lokidb/fs-storage\"] = factory(root[\"fs\"]); root[\"LokiFsStorage\"] = root[\"@lokidb/fs-storage\"].default; }\n})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE__0__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// define __esModule on exports\n/******/ \t__webpack_require__.r = function(exports) {\n/******/ \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t}\n/******/ \t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t};\n/******/\n/******/ \t// create a fake namespace object\n/******/ \t// mode & 1: value is a module id, require it\n/******/ \t// mode & 2: merge all properties of value into the ns\n/******/ \t// mode & 4: return value when already ns object\n/******/ \t// mode & 8|1: behave like require\n/******/ \t__webpack_require__.t = function(value, mode) {\n/******/ \t\tif(mode & 1) value = __webpack_require__(value);\n/******/ \t\tif(mode & 8) return value;\n/******/ \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n/******/ \t\tvar ns = Object.create(null);\n/******/ \t\t__webpack_require__.r(ns);\n/******/ \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n/******/ \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n/******/ \t\treturn ns;\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 3);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE__0__;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return PLUGINS; });\nfunction getGlobal() {\n let glob;\n (function (global) {\n glob = global;\n })(global !== undefined && global || this);\n return glob;\n}\nfunction create() {\n const global = getGlobal();\n const sym = Symbol.for(\"LOKI\");\n if (global[sym] === undefined) {\n global[sym] = {};\n }\n return global[sym];\n}\n/**\n * @hidden\n */\nconst PLUGINS = create();\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(2)))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\nvar g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"FSStorage\", function() { return FSStorage; });\n/* harmony import */ var _common_plugin__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);\n/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0);\n/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);\n\n\n/**\n * A loki persistence adapter which persists using node fs module.\n */\nclass FSStorage {\n /**\n * Registers the fs storage as plugin.\n */\n static register() {\n _common_plugin__WEBPACK_IMPORTED_MODULE_0__[/* PLUGINS */ \"a\"][\"FSStorage\"] = FSStorage;\n }\n /**\n * Deregisters the fs storage as plugin.\n */\n static deregister() {\n delete _common_plugin__WEBPACK_IMPORTED_MODULE_0__[/* PLUGINS */ \"a\"][\"FSStorage\"];\n }\n /**\n * Load data from file, will throw an error if the file does not exist\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname) {\n return new Promise((resolve, reject) => {\n fs__WEBPACK_IMPORTED_MODULE_1__[\"stat\"](dbname, (err, stats) => {\n if (!err && stats.isFile()) {\n fs__WEBPACK_IMPORTED_MODULE_1__[\"readFile\"](dbname, {\n encoding: \"utf8\"\n }, function readFileCallback(err, data) {\n if (err) {\n reject(err);\n }\n else {\n resolve(data);\n }\n });\n }\n else {\n reject(null);\n }\n });\n });\n }\n /**\n * Save data to file, will throw an error if the file can't be saved\n * might want to expand this to avoid dataloss on partial save\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was persisted\n */\n saveDatabase(dbname, dbstring) {\n const tmpdbname = dbname + \"~\";\n return new Promise((resolve, reject) => {\n fs__WEBPACK_IMPORTED_MODULE_1__[\"writeFile\"](tmpdbname, dbstring, (err) => {\n if (err) {\n reject(err);\n }\n else {\n fs__WEBPACK_IMPORTED_MODULE_1__[\"rename\"](tmpdbname, dbname, (err) => {\n if (err) {\n reject(err);\n }\n else {\n resolve();\n }\n });\n }\n });\n });\n }\n /**\n * Delete the database file, will throw an error if the\n * file can't be deleted\n * @param {string} dbname - the filename of the database to delete\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname) {\n return new Promise((resolve, reject) => {\n fs__WEBPACK_IMPORTED_MODULE_1__[\"unlink\"](dbname, function deleteDatabaseCallback(err) {\n if (err) {\n reject(err);\n }\n else {\n resolve();\n }\n });\n });\n }\n}\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=lokidb.fs-storage.js.map"
},
{
"path": "dist/packages/fs-storage/types/common/plugin.d.ts",
"content": "/**\n * @hidden\n */\nexport declare const PLUGINS: void;\n"
},
{
"path": "dist/packages/fs-storage/types/common/types.d.ts",
"content": "/**\n * @hidden\n */\nimport { Loki } from \"../loki/src/loki\";\nexport interface StorageAdapter {\n loadDatabase(dbname: string): Promise;\n saveDatabase?(dbname: string, serialization: string): Promise;\n deleteDatabase?(dbname: string): Promise;\n mode?: string;\n exportDatabase?(dbname: string, dbref: Loki): Promise;\n}\nexport declare type Doc = T & {\n $loki: number;\n meta?: {\n created: number;\n revision: number;\n version: number;\n updated?: number;\n };\n};\nexport interface Dict {\n [index: string]: T;\n [index: number]: T;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/fs-storage/src/fs_storage.d.ts",
"content": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists using node fs module.\n */\nexport declare class FSStorage implements StorageAdapter {\n /**\n * Registers the fs storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the fs storage as plugin.\n */\n static deregister(): void;\n /**\n * Load data from file, will throw an error if the file does not exist\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise;\n /**\n * Save data to file, will throw an error if the file can't be saved\n * might want to expand this to avoid dataloss on partial save\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was persisted\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * Delete the database file, will throw an error if the\n * file can't be deleted\n * @param {string} dbname - the filename of the database to delete\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/fs-storage/src/index.d.ts",
"content": "import { FSStorage } from \"./fs_storage\";\nexport { FSStorage };\nexport default FSStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/analyzer.d.ts",
"content": "import { CharacterFilter } from \"./character_filter\";\nimport { Tokenizer, whitespaceTokenizer } from \"./tokenizer\";\nimport { lowercaseTokenFilter, TokenFilter } from \"./token_filter\";\n/**\n * A analyzer converts a string into tokens which are added to the inverted index for searching.\n */\nexport interface Analyzer {\n /**\n * The character filters of the analyzer.\n */\n char_filter?: CharacterFilter[];\n /**\n * The tokenizer of the analyzer.\n */\n tokenizer: Tokenizer;\n /**\n * The token filters of the analyzer.\n */\n token_filter?: TokenFilter[];\n}\n/**\n * Analyzes a given string.\n * @param {Analyzer} analyzer - the analyzer\n * @param {string} str - the string\n * @returns {string[]} - the tokens\n */\nexport declare function analyze(analyzer: Analyzer, str: string): string[];\n/**\n * An analyzer with the whitespace tokenizer and the lowercase token filter.\n */\nexport declare class StandardAnalyzer implements Analyzer {\n tokenizer: typeof whitespaceTokenizer;\n token_filter: (typeof lowercaseTokenFilter)[];\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/character_filter.d.ts",
"content": "/**\n * A character filter is used to preprocess a string before it is passed to a tokenizer.\n */\nexport declare type CharacterFilter = (value: string) => string;\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/token_filter.d.ts",
"content": "/**\n * A token filter takes tokens from a tokenizer and modify, delete or add tokens.\n */\nexport declare type TokenFilter = (value: string, index: number, array: string[]) => string;\n/**\n * Converts a token to lowercase.\n * @param {string} token - the token\n * @returns {string} - the lowercased token\n */\nexport declare function lowercaseTokenFilter(token: string): string;\n/**\n * Converts a token to uppercase.\n * @param {string} token - the token\n * @returns {string} - the uppercased token\n */\nexport declare function uppercaseTokenFilter(token: string): string;\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/tokenizer.d.ts",
"content": "/**\n * A tokenizer splits a string into individual tokens.\n */\nexport declare type Tokenizer = (value: string) => string[];\n/**\n * Splits a string at whitespace characters into tokens.\n * @param {string} value - the string\n * @returns {string[]} - the tokens\n */\nexport declare function whitespaceTokenizer(value: string): string[];\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/full_text_search.d.ts",
"content": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./query_types\";\nimport { Scorer } from \"./scorer\";\nimport { Analyzer } from \"./analyzer/analyzer\";\nexport declare class FullTextSearch {\n private _id;\n private _docs;\n private _idxSearcher;\n private _invIdxs;\n /**\n * Registers the full-text search as plugin.\n */\n static register(): void;\n /**\n * Initialize the full-text search for the given fields.\n * @param {object[]} fieldOptions - the field options\n * @param {string} fieldOptions.field - the name of the property field\n * @param {boolean=true} fieldOptions.store - flag to indicate if the full-text search should be stored on serialization or\n * rebuild on deserialization\n * @param {boolean=true} fieldOptions.optimizeChanges - flag to optimize updating and deleting of documents\n * (requires more memory but performs faster)\n * @param {Analyzer} fieldOptions.analyzer - an analyzer for the field\n * @param {string} [id] - the property name of the document index\n */\n constructor(fieldOptions?: FullTextSearch.FieldOptions[], id?: string);\n addDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;\n removeDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;\n updateDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;\n clear(): void;\n search(query: Query): Scorer.ScoreResults;\n toJSON(): FullTextSearch.Serialization;\n static fromJSONObject(serialized: FullTextSearch.Serialization, analyzers?: Dict): FullTextSearch;\n}\nexport declare namespace FullTextSearch {\n interface FieldOptions extends InvertedIndex.FieldOptions {\n field: string;\n }\n interface Serialization {\n id: string;\n ii: Dict;\n }\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/automaton.d.ts",
"content": "/**\n * Transition with dest, min and max.\n * @hidden\n */\nexport declare type Transition = [number, number, number];\n/**\n * @type {number}\n * @hidden\n */\nexport declare const MIN_CODE_POINT = 0;\n/**\n * @type {number}\n * @hidden\n */\nexport declare const MAX_CODE_POINT = 1114111;\n/**\n * From org/apache/lucene/util/automaton/Automaton.java\n * @hidden\n */\nexport declare class Automaton {\n private _stateTransitions;\n private _accept;\n private _nextState;\n private _currState;\n private _transitions;\n constructor();\n isAccept(n: number): boolean;\n createState(): number;\n setAccept(state: number, accept: boolean): void;\n finishState(): void;\n private _finishCurrentState();\n getStartPoints(): number[];\n step(state: number, label: number): number;\n getNumStates(): number;\n addTransition(source: number, dest: number, min: number, max: number): void;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts",
"content": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev1TParametricDescription.java\n * @hidden\n */\nexport declare class Lev1TParametricDescription extends ParametricDescription {\n constructor(w: number);\n transition(absState: number, position: number, vector: number): number;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts",
"content": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev2TParametricDescription.java\n * @hidden\n */\nexport declare class Lev2TParametricDescription extends ParametricDescription {\n constructor(w: number);\n transition(absState: number, position: number, vector: number): number;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts",
"content": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidden\n */\nexport declare class LevenshteinAutomata {\n private _word;\n private _numRanges;\n private _rangeLower;\n private _rangeUpper;\n private _description;\n private _alphabet;\n private _editDistance;\n constructor(input: number[], editDistance: number);\n /**\n * Transforms the NDFA to a DFA.\n * @returns {Automaton}\n */\n toAutomaton(): Automaton;\n private _getVector(x, pos, end);\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/long.d.ts",
"content": "/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nexport declare class Long {\n private _low;\n private _high;\n constructor(low?: number, high?: number);\n /**\n * Returns this long with bits arithmetically shifted to the right by the given amount.\n * @param {number} numBits - number of bits\n * @returns {Long} the long\n */\n shiftRight(numBits: number): Long;\n /**\n * Returns this long with bits arithmetically shifted to the left by the given amount.\n * @param {number} numBits - number of bits\n * @returns {Long} the long\n */\n shiftLeft(numBits: number): Long;\n /**\n * Returns the bitwise AND of this Long and the specified.\n * @param {Long} other - the other Long\n * @returns {Long} the long\n */\n and(other: Long): Long;\n /**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @returns {number}\n */\n toInt(): number;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts",
"content": "import { Long } from \"./long\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescription\n * @hidden\n */\nexport declare class ParametricDescription {\n protected _w: number;\n private _n;\n private _minErrors;\n constructor(w: number, n: number, minErrors: number[]);\n /**\n * Return the number of states needed to compute a Levenshtein DFA\n */\n size(): number;\n /**\n * Returns true if the state in any Levenshtein DFA is an accept state (final state).\n */\n isAccept(absState: number): boolean;\n /**\n * Returns the position in the input word for a given state.\n * This is the minimal boundary for the state.\n */\n getPosition(absState: number): number;\n static unpack(data: Long[], index: number, bitsPerValue: number): number;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts",
"content": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\nexport declare class RunAutomaton {\n private _points;\n private _accept;\n private _transitions;\n private _classmap;\n constructor(automaton: Automaton);\n getCharClass(c: number): number;\n step(state: number, c: number): number;\n isAccept(state: number): boolean;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/index.d.ts",
"content": "import { FullTextSearch } from \"./full_text_search\";\nimport { analyze, StandardAnalyzer } from \"./analyzer/analyzer\";\nimport { whitespaceTokenizer } from \"./analyzer/tokenizer\";\nimport { lowercaseTokenFilter, uppercaseTokenFilter } from \"./analyzer/token_filter\";\nexport { FullTextSearch, analyze, StandardAnalyzer, whitespaceTokenizer, lowercaseTokenFilter, uppercaseTokenFilter };\nexport default FullTextSearch;\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/index_searcher.d.ts",
"content": "import { Scorer } from \"./scorer\";\nimport { InvertedIndex } from \"./inverted_index\";\nimport { Query } from \"./query_types\";\nimport { Dict } from \"../../common/types\";\n/**\n * @hidden\n */\nexport declare class IndexSearcher {\n private _invIdxs;\n private _docs;\n private _scorer;\n /**\n * Constructs an index searcher.\n * @param {Dict} invIdxs - the inverted indexes\n * @param {Set} docs - the ids of the documents\n */\n constructor(invIdxs: Dict, docs: Set);\n search(query: Query): Scorer.ScoreResults;\n setDirty(): void;\n private _recursive(query, doScoring);\n private _getUnique(queries, doScoring, queryResults);\n private _getAll(queries, doScoring, queryResults?);\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/inverted_index.d.ts",
"content": "import { Analyzer } from \"./analyzer/analyzer\";\n/**\n * Converts a string into an array of code points.\n * @param str - the string\n * @returns {number[]} to code points\n * @hidden\n */\nexport declare function toCodePoints(str: string): number[];\n/**\n * Inverted index class handles featured text search for specific document fields.\n * @hidden\n */\nexport declare class InvertedIndex {\n analyzer: Analyzer;\n docCount: number;\n docStore: Map;\n totalFieldLength: number;\n root: InvertedIndex.Index;\n private _store;\n private _optimizeChanges;\n /**\n * @param {boolean} [options.store=true] - inverted index will be stored at serialization rather than rebuilt on load\n * @param {boolean} [options.optimizeChanges=true] - flag to store additional metadata inside the index for better\n * performance if an existing field is updated or removed\n * @param {Analyzer} [options.analyzer=] - the analyzer of this inverted index\n */\n constructor(options?: InvertedIndex.FieldOptions);\n /**\n * Adds defined fields of a document to the inverted index.\n * @param {string} field - the field to add\n * @param {number} docId - the doc id of the field\n */\n insert(field: string, docId: InvertedIndex.DocumentIndex): void;\n /**\n * Removes all relevant terms of a document from the inverted index.\n * @param {number} docId - the document.\n */\n remove(docId: InvertedIndex.DocumentIndex): void;\n /**\n * Gets the term index of a term.\n * @param {string} term - the term\n * @param {object} root - the term index to start from\n * @param {number} start - the position of the term string to start from\n * @return {object} - The term index or null if the term is not in the term tree.\n */\n static getTermIndex(term: number[], root: InvertedIndex.Index, start?: number): InvertedIndex.Index;\n /**\n * Extends a term index to all available term leafs.\n * @param {object} idx - the term index to start from\n * @param {number[]} [term=[]] - the current term\n * @param {Array} termIndices - all extended indices with their term\n * @returns {Array} - Array with term indices and extension\n */\n static extendTermIndex(idx: InvertedIndex.Index, term?: number[], termIndices?: InvertedIndex.IndexTerm[]): InvertedIndex.IndexTerm[];\n /**\n * Serialize the inverted index.\n * @returns {{docStore: *, _fields: *, index: *}}\n */\n toJSON(): InvertedIndex.Serialization;\n /**\n * Deserialize the inverted index.\n * @param {{docStore: *, _fields: *, index: *}} serialized - The serialized inverted index.\n * @param {Analyzer} analyzer[undefined] - an analyzer\n */\n static fromJSONObject(serialized: InvertedIndex.Serialization, analyzer?: Analyzer): InvertedIndex;\n private static _serializeIndex(idx);\n private static _deserializeIndex(serialized);\n /**\n * Set parent of to each index and regenerate the indexRef.\n * @param {Index} index - the index\n * @param {Index} parent - the parent\n */\n private _regenerate(index, parent);\n /**\n * Iterate over the whole inverted index and remove the document.\n * Delete branch if not needed anymore.\n * Function is needed if index is used without optimization.\n * @param {Index} idx - the index\n * @param {number} docId - the doc id\n * @returns {boolean} true if index is empty\n */\n private _remove(idx, docId);\n}\nexport declare namespace InvertedIndex {\n interface FieldOptions {\n store?: boolean;\n optimizeChanges?: boolean;\n analyzer?: Analyzer;\n }\n type Index = Map & {\n dc?: Map;\n df?: number;\n pa?: Index;\n };\n type IndexTerm = {\n index: Index;\n term: number[];\n };\n interface SerializedIndex {\n d?: {\n df: number;\n dc: [DocumentIndex, number][];\n };\n k?: number[];\n v?: SerializedIndex[];\n }\n type Serialization = SpareSerialization | FullSerialization;\n type SpareSerialization = {\n _store: false;\n _optimizeChanges: boolean;\n };\n type FullSerialization = {\n _store: true;\n _optimizeChanges: boolean;\n docCount: number;\n docStore: [DocumentIndex, DocStore][];\n totalFieldLength: number;\n root: SerializedIndex;\n };\n interface DocStore {\n fieldLength?: number;\n indexRef?: Index[];\n }\n type DocumentIndex = number | string;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/query_types.d.ts",
"content": "/**\n * Base query to enable boost to a query type.\n */\nexport interface BaseQuery {\n type: Type;\n boost?: number;\n}\n/**\n * A query which finds documents where a document field contains a term.\n */\nexport interface TermQuery extends BaseQuery<\"term\"> {\n field: string;\n value: string;\n}\n/**\n * A query which finds documents where a document field contains any of the terms.\n */\nexport interface TermsQuery extends BaseQuery<\"terms\"> {\n field: string;\n value: string[];\n}\n/**\n * A query which finds documents where the wildcard term can be applied at an existing document field term.\n */\nexport interface WildcardQuery extends BaseQuery<\"wildcard\"> {\n field: string;\n value: string;\n enable_scoring?: boolean;\n}\n/**\n * A query which finds documents where the fuzzy term can be transformed into an existing document field term within a\n * given edit distance.\n */\nexport interface FuzzyQuery extends BaseQuery<\"fuzzy\"> {\n field: string;\n value: string;\n fuzziness?: 0 | 1 | 2 | \"AUTO\";\n prefix_length?: number;\n extended?: boolean;\n}\n/**\n * A query which matches documents containing the prefix of a term inside a field.\n */\nexport interface PrefixQuery extends BaseQuery<\"prefix\"> {\n field: string;\n value: string;\n enable_scoring?: boolean;\n}\n/**\n * A query which matches all documents with a given field.\n */\nexport interface ExistsQuery extends BaseQuery<\"exists\"> {\n field: string;\n}\n/**\n * A query which tokenizes the given text into tokens and performs a sub query for each token. The results are combined\n * using a boolean operator.\n */\nexport interface MatchQuery extends BaseQuery<\"match\"> {\n field: string;\n value: string;\n minimum_should_match?: number | string;\n operator?: \"and\" | \"or\";\n fuzziness?: 0 | 1 | 2 | \"AUTO\";\n prefix_length?: number;\n extended?: boolean;\n}\n/**\n * A query that matches all documents and giving them a constant score equal to the query boost.\n*/\nexport interface MatchQueryAll extends BaseQuery<\"match_all\"> {\n}\n/**\n * A query that wraps sub queries and returns a constant score equal to the query boost for every document in the filter.\n */\nexport interface ConstantScoreQuery extends BaseQuery<\"constant_score\"> {\n filter: QueryTypes[];\n}\n/**\n * A query that matches documents matching boolean combinations of sub queries.\n */\nexport interface BoolQuery extends BaseQuery<\"bool\"> {\n must?: QueryTypes[];\n filter?: QueryTypes[];\n should?: QueryTypes[];\n not?: QueryTypes[];\n minimum_should_match?: number | string;\n}\n/**\n * Union type of possible query types.\n */\nexport declare type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuery | WildcardQuery | FuzzyQuery | MatchQuery | MatchQueryAll | PrefixQuery | ExistsQuery;\n/**\n * The main query with the actually full-text search query and the scoring parameters.\n */\nexport interface Query {\n query: QueryTypes;\n calculate_scoring?: boolean;\n explain?: boolean;\n bm25?: {\n k1: number;\n b: number;\n };\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/scorer.d.ts",
"content": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./query_types\";\n/**\n * @hidden\n */\nexport declare class Scorer {\n private _invIdxs;\n private _cache;\n constructor(invIdxs: Dict);\n setDirty(): void;\n score(fieldName: string, boost: number, termIdx: InvertedIndex.Index, doScoring: boolean | null, queryResults: Scorer.QueryResults, term: number[], df?: number): void;\n scoreConstant(boost: number, docId: InvertedIndex.DocumentIndex, queryResults: Scorer.QueryResults): Scorer.QueryResults;\n finalScore(query: Query, queryResults: Scorer.QueryResults): Scorer.ScoreResults;\n private static _calculateFieldLength(fieldLength);\n private _getCache(fieldName);\n /**\n * Returns the idf by either calculate it or use a cached one.\n * @param {string} fieldName - the name of the field\n * @param {number} docFreq - the doc frequency of the term\n * @returns {number} the idf\n * @private\n */\n private _idf(fieldName, docFreq);\n private _avgFieldLength(fieldName);\n}\nexport declare namespace Scorer {\n interface IDFCache {\n idfs: Dict;\n avgFieldLength: number;\n }\n interface QueryResult {\n tf?: number;\n idf?: number;\n boost: number;\n fieldName?: string;\n term?: number[];\n }\n type QueryResults = Map;\n interface BM25Explanation {\n boost: number;\n score: number;\n docID: number;\n fieldName: string;\n index: string;\n idf: number;\n tfNorm: number;\n tf: number;\n fieldLength: number;\n avgFieldLength: number;\n }\n interface ConstantExplanation {\n boost: number;\n score: number;\n }\n type ScoreExplanation = BM25Explanation | ConstantExplanation;\n type ScoreResult = {\n score: number;\n explanation?: ScoreExplanation[];\n };\n type ScoreResults = Dict;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language/src/index.d.ts",
"content": "export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from \"./language\";\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language/src/language.d.ts",
"content": "export declare function generateTrimmer(wordCharacters: string): (token: string) => string;\nexport declare function generateStopWordFilter(stopWords: string[]): (token: string) => string;\nexport declare class Among {\n s_size: number;\n s: number[];\n substring_i: number;\n result: number;\n method: any;\n constructor(s: string, substring_i: number, result: number, method?: any);\n}\nexport declare class SnowballProgram {\n current: string;\n bra: number;\n ket: number;\n limit: number;\n cursor: number;\n limit_backward: number;\n constructor();\n setCurrent(word: string): void;\n getCurrent(): string;\n in_grouping(s: number[], min: number, max: number): boolean;\n in_grouping_b(s: number[], min: number, max: number): boolean;\n out_grouping(s: number[], min: number, max: number): boolean;\n out_grouping_b(s: number[], min: number, max: number): boolean;\n eq_s(s_size: number, s: string): boolean;\n eq_s_b(s_size: number, s: string): boolean;\n find_among(v: Among[], v_size: number): number;\n find_among_b(v: Among[], v_size: number): number;\n replace_s(c_bra: number, c_ket: number, s: string): number;\n slice_check(): void;\n slice_from(s: string): void;\n slice_del(): void;\n insert(c_bra: number, c_ket: number, s: string): void;\n slice_to(): string;\n eq_v_b(s: string): boolean;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-de/src/german_analyzer.d.ts",
"content": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class GermanAnalyzer implements Analyzer {\n tokenizer: (str: string) => string[];\n token_filter: ((token: string) => string)[];\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-de/src/index.d.ts",
"content": "import { GermanAnalyzer } from \"./german_analyzer\";\nexport { GermanAnalyzer };\nexport default GermanAnalyzer;\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-en/src/english_analyzer.d.ts",
"content": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class EnglishAnalyzer implements Analyzer {\n tokenizer: (str: string) => string[];\n token_filter: ((token: string) => string)[];\n}\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-en/src/index.d.ts",
"content": "import { EnglishAnalyzer } from \"./english_analyzer\";\nexport { EnglishAnalyzer };\nexport default EnglishAnalyzer;\n"
},
{
"path": "dist/packages/fs-storage/types/indexed-storage/src/index.d.ts",
"content": "import { IndexedStorage } from \"./indexed_storage\";\nexport { IndexedStorage };\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/indexed-storage/src/indexed_storage.d.ts",
"content": "import { StorageAdapter } from \"../../common/types\";\n/**\n * Loki persistence adapter class for indexedDb.\n * This class fulfills abstract adapter interface which can be applied to other storage methods.\n * Utilizes the included LokiCatalog app/key/value database for actual database persistence.\n * IndexedDb storage is provided per-domain, so we implement app/key/value database to\n * allow separate contexts for separate apps within a domain.\n */\nexport declare class IndexedStorage implements StorageAdapter {\n private _appname;\n private catalog;\n /**\n * Registers the indexed storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the indexed storage as plugin.\n */\n static deregister(): void;\n /**\n * @param {string} [appname=loki] - Application name context can be used to distinguish subdomains, \"loki\" by default\n */\n constructor(appname?: string);\n /**\n * Retrieves a serialized db string from the catalog.\n *\n * @example\n * // LOAD\n * var idbAdapter = new LokiIndexedAdapter(\"finance\");\n * var db = new loki(\"test\", { adapter: idbAdapter });\n * db.base(function(result) {\n * console.log(\"done\");\n * });\n *\n * @param {string} dbname - the name of the database to retrieve.\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise<{}>;\n /**\n * Saves a serialized db to the catalog.\n *\n * @example\n * // SAVE : will save App/Key/Val as \"finance\"/\"test\"/{serializedDb}\n * let idbAdapter = new LokiIndexedAdapter(\"finance\");\n * let db = new loki(\"test\", { adapter: idbAdapter });\n * let coll = db.addCollection(\"testColl\");\n * coll.insert({test: \"val\"});\n * db.saveDatabase(); // could pass callback if needed for async complete\n *\n * @param {string} dbname - the name to give the serialized database within the catalog.\n * @param {string} dbstring - the serialized db string to save.\n * @returns {Promise} a Promise that resolves after the database was persisted\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * Deletes a serialized db from the catalog.\n *\n * @example\n * // DELETE DATABASE\n * // delete \"finance\"/\"test\" value from catalog\n * idbAdapter.deleteDatabase(\"test\", function {\n * // database deleted\n * });\n *\n * @param {string} dbname - the name of the database to delete from the catalog.\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n /**\n * Removes all database partitions and pages with the base filename passed in.\n * This utility method does not (yet) guarantee async deletions will be completed before returning\n *\n * @param {string} dbname - the base filename which container, partitions, or pages are derived\n */\n deleteDatabasePartitions(dbname: string): void;\n /**\n * Retrieves object array of catalog entries for current app.\n *\n * @example\n * idbAdapter.getDatabaseList(function(result) {\n * // result is array of string names for that appcontext (\"finance\")\n * result.forEach(function(str) {\n * console.log(str);\n * });\n * });\n *\n * @param {function} callback - should accept array of database names in the catalog for current app.\n */\n getDatabaseList(callback: (names: string[]) => void): void;\n /**\n * Allows retrieval of list of all keys in catalog along with size\n * @param {function} callback - (Optional) callback to accept result array.\n */\n getCatalogSummary(callback: (entry: Entry[]) => void): void;\n}\nexport interface Entry {\n app: string;\n key: string;\n size: number;\n}\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/local-storage/src/index.d.ts",
"content": "import { LocalStorage } from \"./local_storage\";\nexport { LocalStorage };\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/local-storage/src/local_storage.d.ts",
"content": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists to web browser's local storage object\n * @constructor LocalStorageAdapter\n */\nexport declare class LocalStorage implements StorageAdapter {\n /**\n * Registers the local storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the local storage as plugin.\n */\n static deregister(): void;\n /**\n * loadDatabase() - Load data from localstorage\n * @param {string} dbname - the name of the database to load\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise;\n /**\n * saveDatabase() - save data to localstorage, will throw an error if the file can't be saved\n * might want to expand this to avoid dataloss on partial save\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was saved\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * deleteDatabase() - delete the database from localstorage, will throw an error if it\n * can't be deleted\n * @param {string} dbname - the filename of the database to delete\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n}\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/avl_index.d.ts",
"content": "import { IRangedIndex, IRangedIndexRequest } from \"./ranged_indexes\";\nimport { ILokiComparer } from \"./comparators\";\n/**\n * Treenode type for binary search tree (BST) implementation.\n *\n * To support duplicates, we may need to either repurpose parent to\n * point to 'elder' sibling or add a siblingId to point to owner of\n * node represented in tree.\n */\nexport declare type TreeNode = {\n id: number;\n value: T;\n parent: number | null;\n balance: number;\n height: number;\n left: number | null;\n right: number | null;\n siblings: number[];\n};\nexport interface ITreeNodeHash {\n [id: number]: TreeNode;\n}\n/**\n * LokiDB AVL Balanced Binary Tree Index implementation.\n * To support duplicates, we use siblings (array) in tree nodes.\n * Basic AVL components guided by William Fiset tutorials at :\n * https://github.com/williamfiset/data-structures/blob/master/com/williamfiset/datastructures/balancedtree/AVLTreeRecursive.java\n * https://www.youtube.com/watch?v=g4y2h70D6Nk&list=PLDV1Zeh2NRsD06x59fxczdWLhDDszUHKt\n */\nexport declare class AvlTreeIndex implements IRangedIndex {\n name: string;\n comparator: ILokiComparer;\n nodes: ITreeNodeHash;\n apex: number | null;\n /**\n * Initializes index with property name and a comparer function.\n */\n constructor(name: string, comparator: ILokiComparer);\n backup(): AvlTreeIndex;\n restore(tree: AvlTreeIndex): void;\n /**\n * Used for inserting a new value into the BinaryTreeIndex\n * @param id Unique Id (such as $loki) to associate with value\n * @param val Value to be indexed and inserted into binary tree\n */\n insert(id: number, val: T): void;\n /**\n * Recursively inserts a treenode and re-balances if needed.\n * @param current\n * @param node\n */\n insertNode(current: TreeNode, node: TreeNode): number;\n /**\n * Updates height and balance (calculation) for tree node\n * @param node\n */\n private updateBalance(node);\n /**\n * Balance the 'double left-heavy' condition\n * @param node\n */\n private leftLeftCase(node);\n /**\n * Balance the '(parent) left heavy, (child) right heavy' condition\n * @param node\n */\n private leftRightCase(node);\n /**\n * Balance the 'double right-heavy' condition\n * @param node\n */\n private rightRightCase(node);\n /**\n * Balance the '(parent) right heavy, (child) left heavy' condition\n * @param node\n */\n private rightLeftCase(node);\n /**\n * Left rotation of node. Swaps right child into current location.\n * @param node\n */\n private rotateLeft(node);\n /**\n * Right rotation of node. Swaps left child into current location.\n * @param node\n */\n private rotateRight(node);\n /**\n * Diagnostic method for examining tree contents and structure\n * @param node\n */\n getValuesAsTree(node?: TreeNode): any;\n /**\n * Updates a value, possibly relocating it, within binary tree\n * @param id Unique Id (such as $loki) to associate with value\n * @param val New value to be indexed within binary tree\n */\n update(id: number, val: T): void;\n /**\n * Removes a value from the binary tree index\n * @param id\n */\n remove(id: number): void;\n /**\n * Recursive node removal and rebalancer\n * @param node\n * @param val\n */\n private removeNode(node, id);\n /**\n * Utility method for updating a parent's child link when it changes\n * @param parentId\n * @param oldChildId\n * @param newChildId\n */\n private updateChildLink(parentId, oldChildId, newChildId);\n /**\n * When removing a parent with only child, this does simple remap of child to grandParent.\n * @param grandParent New parent of 'child'.\n * @param parent Node being removed.\n * @param child Node to reparent to grandParent.\n */\n private promoteChild(parent, child);\n /**\n * Finds a successor to a node and replaces that node with it.\n * @param node\n */\n private promoteSuccessor(node);\n /**\n * Utility method for finding In-Order predecessor to the provided node\n * @param node Parent node to find leaf node of greatest 'value'\n */\n private findGreaterLeaf(node);\n /**\n * Utility method for finding In-Order successor to the provided node\n * @param node Parent Node to find leaf node of least 'value'\n */\n private findLesserLeaf(node);\n /**\n * Interface method to support ranged queries. Results sorted by index property.\n * @param range Options for ranged request.\n */\n rangeRequest(range?: IRangedIndexRequest): number[];\n /**\n * Implements ranged request operations.\n * @param node\n * @param range\n */\n private collateRequest(node, range);\n /**\n * Used on a branch node to return an array of id within that branch, sorted by their value\n * @param node\n */\n private collateIds(node);\n /**\n * Traverses tree to a node matching the provided value.\n * @param node\n * @param val\n */\n /**\n * Inline/Non-recusive 'single value' ($eq) lookup.\n * Traverses tree to a node matching the provided value.\n * @param node\n * @param val\n */\n private locate(node, val);\n /**\n * Index integrity check (IRangedIndex interface function)\n */\n validateIndex(): boolean;\n /**\n * Recursive Node validation routine\n * @param node\n */\n private validateNode(node);\n}\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/clone.d.ts",
"content": "export declare type CloneMethod = \"parse-stringify\" | \"deep\" | \"shallow\" | \"shallow-recurse\";\n/**\n * @hidden\n */\nexport declare function clone(data: T, method?: CloneMethod): T;\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/collection.d.ts",
"content": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { UniqueIndex } from \"./unique_index\";\nimport { ResultSet } from \"./result_set\";\nimport { DynamicView } from \"./dynamic_view\";\nimport { IRangedIndex } from \"./ranged_indexes\";\nimport { CloneMethod } from \"./clone\";\nimport { Doc, Dict } from \"../../common/types\";\nimport { FullTextSearch } from \"../../full-text-search/src/full_text_search\";\nimport { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\n/**\n * Collection class that handles documents of same type\n * @extends LokiEventEmitter\n * @param - the data type\n * @param - nested properties of data type\n */\nexport declare class Collection extends LokiEventEmitter {\n name: string;\n _data: Doc[];\n private _idIndex;\n _rangedIndexes: {\n [P in keyof T]?: Collection.RangedIndexMeta;\n };\n _lokimap: {\n [$loki: number]: Doc;\n };\n _unindexedSortComparator: string;\n _defaultLokiOperatorPackage: string;\n /**\n * Unique constraints contain duplicate object references, so they are not persisted.\n * We will keep track of properties which have unique constraints applied here, and regenerate on load.\n */\n _constraints: {\n unique: {\n [P in keyof T]?: UniqueIndex;\n };\n };\n /**\n * Transforms will be used to store frequently used query chains as a series of steps which itself can be stored along\n * with the database.\n */\n _transforms: Dict[]>;\n /**\n * In autosave scenarios we will use collection level dirty flags to determine whether save is needed.\n * currently, if any collection is dirty we will autosave the whole database if autosave is configured.\n * Defaulting to true since this is called from addCollection and adding a collection should trigger save.\n */\n _dirty: boolean;\n private _cached;\n /**\n * Is collection transactional.\n */\n private _transactional;\n /**\n * Options to clone objects when inserting them.\n */\n _cloneObjects: boolean;\n /**\n * Default clone method (if enabled) is parse-stringify.\n */\n _cloneMethod: CloneMethod;\n /**\n * If set to true we will not maintain a meta property for a document.\n */\n private _disableMeta;\n /**\n * Disable track changes.\n */\n private _disableChangesApi;\n /**\n * Disable delta update object style on changes.\n */\n _disableDeltaChangesApi: boolean;\n /**\n * By default, if you insert a document with a Date value for an indexed property, we will convert that value to number.\n */\n private _serializableIndexes;\n /**\n * Name of path of used nested properties.\n */\n private _nestedProperties;\n /**\n * Option to activate a cleaner daemon - clears \"aged\" documents at set intervals.\n */\n _ttl: Collection.TTL;\n private _maxId;\n private _dynamicViews;\n /**\n * Changes are tracked by collection and aggregated by the db.\n */\n private _changes;\n /**\n * stages: a map of uniquely identified 'stages', which hold copies of objects to be\n * manipulated without affecting the data in the original collection\n */\n private _stages;\n private _commitLog;\n _fullTextSearch: FullTextSearch;\n /**\n * @param {string} name - collection name\n * @param {(object)} [options={}] - a configuration object\n * @param {string[]} [options.unique=[]] - array of property names to define unique constraints for\n * @param {string[]} [options.exact=[]] - array of property names to define exact constraints for\n * @param {RangedIndexOptions} [options.rangedIndexes] - configuration object for ranged indexes\n * @param {boolean} [options.asyncListeners=false] - whether listeners are invoked asynchronously\n * @param {boolean} [options.disableMeta=false] - set to true to disable meta property on documents\n * @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes API\n * @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)\n * @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user\n * @param {boolean} [options.serializableIndexes=true] - converts date values on binary indexed property values are serializable\n * @param {string} [options.cloneMethod=\"deep\"] - the clone method\n * @param {number} [options.transactional=false] - ?\n * @param {number} [options.ttl=] - age of document (in ms.) before document is considered aged/stale.\n * @param {number} [options.ttlInterval=] - time interval for clearing out 'aged' documents; not set by default\n * @param {string} [options.unindexedSortComparator=\"js\"] \"js\", \"abstract\", \"abstract-date\", \"loki\" or other registered comparator name\n * @param {string} [options.defaultLokiOperatorPackage=\"js\"] \"js\", \"loki\", \"comparator\" (or user defined) query ops package\n * @param {FullTextSearch.FieldOptions} [options.fullTextSearch=] - the full-text search options\n * @see {@link Loki#addCollection} for normal creation of collections\n */\n constructor(name: string, options?: Collection.Options);\n toJSON(): Collection.Serialized;\n static fromJSONObject(obj: Collection.Serialized, options?: Collection.DeserializeOptions): Collection;\n /**\n * Adds a named collection transform to the collection\n * @param {string} name - name to associate with transform\n * @param {array} transform - an array of transformation 'step' objects to save into the collection\n */\n addTransform(name: string, transform: Collection.Transform[]): void;\n /**\n * Retrieves a named transform from the collection.\n * @param {string} name - name of the transform to lookup.\n */\n getTransform(name: string): Collection.Transform[];\n /**\n * Updates a named collection transform to the collection\n * @param {string} name - name to associate with transform\n * @param {object} transform - a transformation object to save into collection\n */\n setTransform(name: string, transform: Collection.Transform[]): void;\n /**\n * Removes a named collection transform from the collection\n * @param {string} name - name of collection transform to remove\n */\n removeTransform(name: string): void;\n private setTTL(age, interval);\n /**\n * Create a row filter that covers all documents in the collection.\n */\n _prepareFullDocIndex(): number[];\n /**\n * Ensure rangedIndex of a field.\n * @param field\n * @param indexTypeName\n * @param comparatorName\n */\n ensureIndex(field: string, indexTypeName?: string, comparatorName?: string): void;\n /**\n * Ensure rangedIndex of a field.\n * @param field Property to create an index on (need to look into contraining on keyof T)\n * @param indexTypeName Name of IndexType factory within (global?) hashmap to create IRangedIndex from\n * @param comparatorName Name of Comparator within (global?) hashmap\n */\n ensureRangedIndex(field: string, indexTypeName?: string, comparatorName?: string): void;\n ensureUniqueIndex(field: keyof T): UniqueIndex;\n /**\n * Quickly determine number of documents in collection (or query)\n * @param {object} query - (optional) query object to count results of\n * @returns {number} number of documents in the collection\n */\n count(query?: ResultSet.Query>): number;\n /**\n * Rebuild idIndex\n */\n private _ensureId();\n /**\n * Add a dynamic view to the collection\n * @param {string} name - name of dynamic view to add\n * @param {object} options - (optional) options to configure dynamic view with\n * @param {boolean} [options.persistent=false] - indicates if view is to main internal results array in 'resultdata'\n * @param {string} [options.sortPriority=SortPriority.PASSIVE] - the sort priority\n * @param {number} options.minRebuildInterval - minimum rebuild interval (need clarification to docs here)\n * @returns {DynamicView} reference to the dynamic view added\n **/\n addDynamicView(name: string, options?: DynamicView.Options): DynamicView;\n /**\n * Remove a dynamic view from the collection\n * @param {string} name - name of dynamic view to remove\n **/\n removeDynamicView(name: string): void;\n /**\n * Look up dynamic view reference from within the collection\n * @param {string} name - name of dynamic view to retrieve reference of\n * @returns {DynamicView} A reference to the dynamic view with that name\n **/\n getDynamicView(name: string): DynamicView;\n /**\n * Applies a 'mongo-like' find query object and passes all results to an update function.\n * @param {object} filterObject - the 'mongo-like' query object\n * @param {function} updateFunction - the update function\n */\n findAndUpdate(filterObject: ResultSet.Query>, updateFunction: (obj: Doc) => any): void;\n /**\n * Applies a 'mongo-like' find query object removes all documents which match that filter.\n * @param {object} filterObject - 'mongo-like' query object\n */\n findAndRemove(filterObject: ResultSet.Query>): void;\n /**\n * Adds object(s) to collection, ensure object(s) have meta properties, clone it if necessary, etc.\n * @param {(object|array)} doc - the document (or array of documents) to be inserted\n * @returns {(object|array)} document or documents inserted\n */\n insert(doc: TData): Doc;\n insert(doc: TData[]): Doc[];\n /**\n * Adds a single object, ensures it has meta properties, clone it if necessary, etc.\n * @param {object} doc - the document to be inserted\n * @param {boolean} bulkInsert - quiet pre-insert and insert event emits\n * @returns {object} document or 'undefined' if there was a problem inserting it\n */\n insertOne(doc: TData, bulkInsert?: boolean): Doc;\n /**\n * Refers nested properties of an object to the root of it.\n * @param {T} data - the object\n * @returns {T & TNested} the object with nested properties\n * @hidden\n */\n _defineNestedProperties(data: U): U & TNested;\n /**\n * Empties the collection.\n * @param {boolean} [removeIndices=false] - remove indices\n */\n clear({removeIndices: removeIndices}?: {\n removeIndices?: boolean;\n }): void;\n /**\n * Updates an object and notifies collection that the document has changed.\n * @param {object} doc - document to update within the collection\n */\n update(doc: Doc | Doc[]): void;\n /**\n * Add object to collection\n */\n private _add(obj);\n /**\n * Applies a filter function and passes all results to an update function.\n * @param {function} filterFunction - the filter function\n * @param {function} updateFunction - the update function\n */\n updateWhere(filterFunction: (obj: Doc) => boolean, updateFunction: (obj: Doc) => Doc): void;\n /**\n * Remove all documents matching supplied filter function.\n * @param {function} filterFunction - the filter function\n */\n removeWhere(filterFunction: (obj: Doc) => boolean): void;\n removeDataOnly(): void;\n /**\n * Remove a document from the collection\n * @param {number|object} doc - document to remove from collection\n */\n remove(doc: number | Doc | Doc[]): void;\n /**\n * Returns all changes.\n * @returns {Collection.Change[]}\n */\n getChanges(): Collection.Change[];\n /**\n * Enables/disables changes api.\n * @param {boolean} disableChangesApi\n * @param {boolean} disableDeltaChangesApi\n */\n setChangesApi(disableChangesApi: boolean, disableDeltaChangesApi?: boolean): void;\n /**\n * Clears all the changes.\n */\n flushChanges(): void;\n private _getObjectDelta(oldObject, newObject);\n /**\n * Compare changed object (which is a forced clone) with existing object and return the delta\n */\n private _getChangeDelta(obj, old);\n /**\n * Creates a clone of the current status of an object and associates operation and collection name,\n * so the parent db can aggregate and generate a changes object for the entire db\n */\n private _createChange(name, op, obj, old?);\n private _createInsertChange(obj);\n private _createUpdateChange(obj, old);\n private _insertMetaWithChange(obj);\n private _updateMetaWithChange(obj, old);\n private _insertMeta(obj);\n private _updateMeta(obj);\n /**\n * Get by Id - faster than other methods because of the searching algorithm\n * @param {int} id - $loki id of document you want to retrieve\n * @param {boolean} returnPosition - if 'true' we will return [object, position]\n * @returns {(object|array|null)} Object reference if document was found, null if not,\n * or an array if 'returnPosition' was passed.\n */\n get(id: number): Doc;\n get(id: number, returnPosition: boolean): Doc | [Doc, number];\n /**\n * Retrieve doc by Unique index\n * @param {string} field - name of uniquely indexed property to use when doing lookup\n * @param {any} value - unique value to search for\n * @returns {object} document matching the value passed\n */\n by(field: keyof T, value: any): Doc;\n /**\n * Find one object by index property, by property equal to value\n * @param {object} query - query object used to perform search with\n * @returns {(object|null)} First matching document, or null if none\n */\n findOne(query: ResultSet.Query>): Doc;\n /**\n * Chain method, used for beginning a series of chained find() and/or view() operations\n * on a collection.\n *\n * @param {array} transform - Ordered array of transform step objects similar to chain\n * @param {object} parameters - Object containing properties representing parameters to substitute\n * @returns {ResultSet} (this) ResultSet, or data array if any map or join functions where called\n */\n chain(transform?: string | Collection.Transform[], parameters?: object): ResultSet;\n /**\n * Find method, api is similar to mongodb.\n * for more complex queries use [chain()]{@link Collection#chain} or [where()]{@link Collection#where}.\n * @example {@tutorial Query Examples}\n * @param {object} query - 'mongo-like' query object\n * @returns {array} Array of matching documents\n */\n find(query?: ResultSet.Query>): Doc[];\n /**\n * Find object by unindexed field by property equal to value,\n * simply iterates and returns the first element matching the query\n */\n findOneUnindexed(prop: string, value: any): Doc;\n /**\n * Transaction methods\n */\n /**\n * start the transation\n */\n startTransaction(): void;\n /**\n * Commit the transaction.\n */\n commit(): void;\n /**\n * Rollback the transaction.\n */\n rollback(): void;\n /**\n * Query the collection by supplying a javascript filter function.\n * @example\n * let results = coll.where(function(obj) {\n * return obj.legs === 8;\n * });\n * @param {function} fun - filter function to run against all collection docs\n * @returns {array} all documents which pass your filter function\n */\n where(fun: (obj: Doc) => boolean): Doc[];\n /**\n * Map Reduce operation\n * @param {function} mapFunction - function to use as map function\n * @param {function} reduceFunction - function to use as reduce function\n * @returns {data} The result of your mapReduce operation\n */\n mapReduce(mapFunction: (value: Doc, index: number, array: Doc[]) => U1, reduceFunction: (array: U1[]) => U2): U2;\n /**\n * Join two collections on specified properties\n * @param {array} joinData - array of documents to 'join' to this collection\n * @param {string} leftJoinProp - property name in collection\n * @param {string} rightJoinProp - property name in joinData\n * @param {function} mapFun - (Optional) map function to use\n * @param dataOptions - options to data() before input to your map function\n * @param [dataOptions.removeMeta] - allows removing meta before calling mapFun\n * @param [dataOptions.forceClones] - forcing the return of cloned objects to your map object\n * @param [dataOptions.forceCloneMethod] - allows overriding the default or collection specified cloning method\n * @returns {ResultSet} Result of the mapping operation\n */\n eqJoin(joinData: Collection | ResultSet | any[], leftJoinProp: string | ((obj: any) => string), rightJoinProp: string | ((obj: any) => string), mapFun?: (left: any, right: any) => any, dataOptions?: ResultSet.DataOptions): ResultSet;\n /**\n * (Staging API) create a stage and/or retrieve it\n */\n getStage(name: string): any;\n /**\n * a collection of objects recording the changes applied through a commmitStage\n */\n /**\n * (Staging API) create a copy of an object and insert it into a stage\n */\n stage(stageName: string, obj: Doc): F;\n /**\n * (Staging API) re-attach all objects to the original collection, so indexes and views can be rebuilt\n * then create a message to be inserted in the commitlog\n * @param {string} stageName - name of stage\n * @param {string} message\n */\n commitStage(stageName: string, message: string): void;\n /**\n * Returns all values of a field.\n * @param {string} field - the field name\n * @return {any}: the array of values\n */\n extract(field: keyof T): any[];\n /**\n * Finds the minimum value of a field.\n * @param {string} field - the field name\n * @return {number} the minimum value\n */\n min(field: keyof T): number;\n /**\n * Finds the maximum value of a field.\n * @param {string} field - the field name\n * @return {number} the maximum value\n */\n max(field: keyof T): number;\n /**\n * Finds the minimum value and its index of a field.\n * @param {string} field - the field name\n * @return {object} - index and value\n */\n minRecord(field: keyof T): {\n index: number;\n value: number;\n };\n /**\n * Finds the maximum value and its index of a field.\n * @param {string} field - the field name\n * @return {object} - index and value\n */\n maxRecord(field: keyof T): {\n index: number;\n value: number;\n };\n /**\n * Returns all values of a field as numbers (if possible).\n * @param {string} field - the field name\n * @return {number[]} - the number array\n */\n extractNumerical(field: keyof T): number[];\n /**\n * Calculates the average numerical value of a field\n * @param {string} field - the field name\n * @returns {number} average of property in all docs in the collection\n */\n avg(field: keyof T): number;\n /**\n * Calculate the standard deviation of a field.\n * @param {string} field - the field name\n * @return {number} the standard deviation\n */\n stdDev(field: keyof T): number;\n /**\n * Calculates the mode of a field.\n * @param {string} field - the field name\n * @return {number} the mode\n */\n mode(field: keyof T): number;\n /**\n * Calculates the median of a field.\n * @param {string} field - the field name\n * @return {number} the median\n */\n median(field: keyof T): number;\n}\nexport declare namespace Collection {\n interface Options {\n unique?: (keyof T)[];\n unindexedSortComparator?: string;\n defaultLokiOperatorPackage?: string;\n rangedIndexes?: RangedIndexOptions;\n serializableIndexes?: boolean;\n asyncListeners?: boolean;\n disableMeta?: boolean;\n disableChangesApi?: boolean;\n disableDeltaChangesApi?: boolean;\n clone?: boolean;\n serializableIndices?: boolean;\n cloneMethod?: CloneMethod;\n transactional?: boolean;\n ttl?: number;\n ttlInterval?: number;\n nestedProperties?: (keyof TNested | {\n name: keyof TNested;\n path: string[];\n })[];\n fullTextSearch?: FullTextSearch.FieldOptions[];\n }\n interface RangedIndexOptions {\n [prop: string]: RangedIndexMeta;\n }\n interface DeserializeOptions {\n retainDirtyFlags?: boolean;\n fullTextSearch?: Dict;\n [collName: string]: any | {\n proto?: any;\n inflate?: (src: object, dest?: object) => void;\n };\n }\n interface BinaryIndex {\n dirty: boolean;\n values: any;\n }\n interface RangedIndexMeta {\n index?: IRangedIndex;\n indexTypeName?: string;\n comparatorName?: string;\n }\n interface Change {\n name: string;\n operation: string;\n obj: any;\n }\n interface Serialized {\n name: string;\n unindexedSortComparator: string;\n defaultLokiOperatorPackage: string;\n _dynamicViews: DynamicView[];\n _nestedProperties: {\n name: string;\n path: string[];\n }[];\n uniqueNames: string[];\n transforms: Dict;\n rangedIndexes: RangedIndexOptions;\n _data: Doc[];\n idIndex: number[];\n maxId: number;\n _dirty: boolean;\n transactional: boolean;\n asyncListeners: boolean;\n disableMeta: boolean;\n disableChangesApi: boolean;\n disableDeltaChangesApi: boolean;\n cloneObjects: boolean;\n cloneMethod: CloneMethod;\n changes: any;\n _fullTextSearch: FullTextSearch;\n }\n interface CheckIndexOptions {\n randomSampling?: boolean;\n randomSamplingFactor?: number;\n repair?: boolean;\n }\n type Transform = {\n type: \"find\";\n value: ResultSet.Query> | string;\n } | {\n type: \"where\";\n value: ((obj: Doc) => boolean) | string;\n } | {\n type: \"simplesort\";\n property: keyof T;\n options?: boolean | ResultSet.SimpleSortOptions;\n } | {\n type: \"compoundsort\";\n value: (keyof T | [keyof T, boolean])[];\n } | {\n type: \"sort\";\n value: (a: Doc, b: Doc) => number;\n } | {\n type: \"sortByScoring\";\n desc?: boolean;\n } | {\n type: \"limit\";\n value: number;\n } | {\n type: \"offset\";\n value: number;\n } | {\n type: \"map\";\n value: (obj: Doc, index: number, array: Doc[]) => any;\n dataOptions?: ResultSet.DataOptions;\n } | {\n type: \"eqJoin\";\n joinData: Collection | ResultSet;\n leftJoinKey: string | ((obj: any) => string);\n rightJoinKey: string | ((obj: any) => string);\n mapFun?: (left: any, right: any) => any;\n dataOptions?: ResultSet.DataOptions;\n } | {\n type: \"mapReduce\";\n mapFunction: (item: Doc, index: number, array: Doc[]) => any;\n reduceFunction: (array: any[]) => any;\n } | {\n type: \"update\";\n value: (obj: Doc) => any;\n } | {\n type: \"remove\";\n };\n interface TTL {\n age: number;\n ttlInterval: number;\n daemon: any;\n }\n}\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/comparators.d.ts",
"content": "export interface ILokiComparer {\n (a: T, b: T): -1 | 0 | 1;\n}\nexport interface IComparatorMap {\n [name: string]: ILokiComparer;\n}\n/** Map/Register of named ILokiComparer functions returning -1, 0, 1 for lt/eq/gt assertions for two passed parameters */\nexport declare let ComparatorMap: IComparatorMap;\n/** Typescript-friendly factory for strongly typed 'js' comparators */\nexport declare function CreateJavascriptComparator(): ILokiComparer;\n/** Typescript-friendly factory for strongly typed 'abstract js' comparators */\nexport declare function CreateAbstractJavascriptComparator(): ILokiComparer;\n/**\n * Comparator which attempts to deal with deal with dates at comparator level.\n * Should work for dates in any of the object, string, and number formats\n */\nexport declare function CreateAbstractDateJavascriptComparator(): ILokiComparer;\n/** Typescript-friendly factory for strongly typed 'loki' comparators */\nexport declare function CreateLokiComparator(): ILokiComparer;\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/dynamic_view.d.ts",
"content": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { ResultSet } from \"./result_set\";\nimport { Collection } from \"./collection\";\nimport { Doc } from \"../../common/types\";\nimport { Scorer } from \"../../full-text-search/src/scorer\";\n/**\n * DynamicView class is a versatile 'live' view class which can have filters and sorts applied.\n * Collection.addDynamicView(name) instantiates this DynamicView object and notifies it\n * whenever documents are add/updated/removed so it can remain up-to-date. (chainable)\n *\n * @example\n * let mydv = mycollection.addDynamicView('test'); // default is non-persistent\n * mydv.applyFind({ 'doors' : 4 });\n * mydv.applyWhere(function(obj) { return obj.name === 'Toyota'; });\n * let results = mydv.data();\n *\n * @extends LokiEventEmitter\n\n * @see {@link Collection#addDynamicView} to construct instances of DynamicView\n *\n * @param - the data type\n * @param - nested properties of data type\n */\nexport declare class DynamicView extends LokiEventEmitter {\n readonly name: string;\n private _collection;\n private _persistent;\n private _sortPriority;\n private _minRebuildInterval;\n private _rebuildPending;\n private _resultSet;\n private _resultData;\n private _resultDirty;\n private _cachedResultSet;\n private _filterPipeline;\n private _sortFunction;\n private _sortCriteria;\n private _sortCriteriaSimple;\n private _sortByScoring;\n private _sortDirty;\n /**\n * Constructor.\n * @param {Collection} collection - a reference to the collection to work agains\n * @param {string} name - the name of this dynamic view\n * @param {object} options - the options\n * @param {boolean} [options.persistent=false] - indicates if view is to main internal results array in 'resultdata'\n * @param {string} [options.sortPriority=\"passive\"] - the sort priority\n * @param {number} [options.minRebuildInterval=1] - minimum rebuild interval (need clarification to docs here)\n */\n constructor(collection: Collection, name: string, options?: DynamicView.Options);\n /**\n * Internally used immediately after deserialization (loading)\n * This will clear out and reapply filterPipeline ops, recreating the view.\n * Since where filters do not persist correctly, this method allows\n * restoring the view to state where user can re-apply those where filters.\n *\n * @param removeWhereFilters\n * @returns {DynamicView} This dynamic view for further chained ops.\n * @fires DynamicView.rebuild\n */\n private _rematerialize({removeWhereFilters});\n /**\n * Makes a copy of the internal ResultSet for branched queries.\n * Unlike this dynamic view, the branched ResultSet will not be 'live' updated,\n * so your branched query should be immediately resolved and not held for future evaluation.\n * @param {(string|array=)} transform - Optional name of collection transform, or an array of transform steps\n * @param {object} parameters - optional parameters (if optional transform requires them)\n * @returns {ResultSet} A copy of the internal ResultSet for branched queries.\n */\n branchResultSet(transform?: string | Collection.Transform[], parameters?: object): ResultSet;\n /**\n * Override of toJSON to avoid circular references.\n */\n toJSON(): DynamicView.Serialized;\n static fromJSONObject(collection: Collection, obj: DynamicView.Serialized): DynamicView;\n /**\n * Used to clear pipeline and reset dynamic view to initial state.\n * Existing options should be retained.\n * @param {boolean} queueSortPhase - (default: false) if true we will async rebuild view (maybe set default to true in future?)\n */\n removeFilters({queueSortPhase}?: {\n queueSortPhase?: boolean;\n }): void;\n /**\n * Used to apply a sort to the dynamic view\n * @example\n * dv.applySort(function(obj1, obj2) {\n * if (obj1.name === obj2.name) return 0;\n * if (obj1.name > obj2.name) return 1;\n * if (obj1.name < obj2.name) return -1;\n * });\n * @param {function} comparefun - a javascript compare function used for sorting\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n applySort(comparefun: (lhs: Doc, rhs: Doc) => number): this;\n /**\n * Used to specify a property used for view translation.\n * @param {string} field - the field name\n * @param {boolean|object=} options - boolean for sort descending or options object\n * @param {boolean} [options.desc=false] - whether we should sort descending.\n * @param {boolean} [options.disableIndexIntersect=false] - whether we should explicity not use array intersection.\n * @param {boolean} [options.forceIndexIntersect=false] - force array intersection (if binary index exists).\n * @param {boolean} [options.useJavascriptSorting=false] - whether results are sorted via basic javascript sort.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n * @example\n * dv.applySimpleSort(\"name\");\n */\n applySimpleSort(field: keyof T, options?: boolean | ResultSet.SimpleSortOptions): this;\n /**\n * Allows sorting a ResultSet based on multiple columns.\n * @param {Array} criteria - array of property names or subarray of [propertyname, isdesc] used evaluate sort order\n * @returns {DynamicView} Reference to this DynamicView, sorted, for future chain operations.\n * @example\n * // to sort by age and then name (both ascending)\n * dv.applySortCriteria(['age', 'name']);\n * // to sort by age (ascending) and then by name (descending)\n * dv.applySortCriteria(['age', ['name', true]]);\n * // to sort by age (descending) and then by name (descending)\n * dv.applySortCriteria([['age', true], ['name', true]]);\n */\n applySortCriteria(criteria: (keyof T | [keyof T, boolean])[]): this;\n /**\n * Used to apply a sort by the latest full-text-search scoring.\n * @param {boolean} [ascending=false] - sort ascending\n */\n applySortByScoring(ascending?: boolean): this;\n /**\n * Returns the scoring of the last full-text-search.\n * @returns {ScoreResult[]}\n */\n getScoring(): Scorer.ScoreResult[];\n /**\n * Marks the beginning of a transaction.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n startTransaction(): this;\n /**\n * Commits a transaction.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n commit(): this;\n /**\n * Rolls back a transaction.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n rollback(): this;\n /**\n * Find the index of a filter in the pipeline, by that filter's ID.\n * @param {(string|number)} uid - The unique ID of the filter.\n * @returns {number}: index of the referenced filter in the pipeline; -1 if not found.\n */\n private _indexOfFilterWithId(uid);\n /**\n * Add the filter object to the end of view's filter pipeline and apply the filter to the ResultSet.\n * @param {object} filter - The filter object. Refer to applyFilter() for extra details.\n */\n private _addFilter(filter);\n /**\n * Reapply all the filters in the current pipeline.\n *\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n reapplyFilters(): this;\n /**\n * Adds or updates a filter in the DynamicView filter pipeline\n * @param {object} filter - A filter object to add to the pipeline.\n * The object is in the format { 'type': filter_type, 'val', filter_param, 'uid', optional_filter_id }\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n applyFilter(filter: DynamicView.Filter): this;\n /**\n * applyFind() - Adds or updates a mongo-style query option in the DynamicView filter pipeline\n *\n * @param {object} query - A mongo-style query object to apply to pipeline\n * @param {(string|number)} uid - Optional: The unique ID of this filter, to reference it in the future.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n applyFind(query: object, uid?: string | number): this;\n /**\n * Adds or updates a javascript filter function in the DynamicView filter pipeline\n * @param {function} fun - A javascript filter function to apply to pipeline\n * @param {(string|number)} uid - Optional: The unique ID of this filter, to reference it in the future.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n applyWhere(fun: (obj: Doc) => boolean, uid?: string | number): this;\n /**\n * Remove the specified filter from the DynamicView filter pipeline\n * @param {(string|number)} uid - The unique ID of the filter to be removed.\n * @returns {DynamicView} this DynamicView object, for further chain ops.\n */\n removeFilter(uid: string | number): this;\n /**\n * Returns the number of documents representing the current DynamicView contents.\n * @returns {number} The number of documents representing the current DynamicView contents.\n */\n count(): number;\n /**\n * Resolves and pending filtering and sorting, then returns document array as result.\n * @param {object} options - optional parameters to pass to ResultSet.data() if non-persistent\n * @param {boolean} [options.forceClones] - Allows forcing the return of cloned objects even when\n * the collection is not configured for clone object.\n * @param {string} [options.forceCloneMethod] - Allows overriding the default or collection specified cloning method.\n * Possible values include 'parse-stringify', 'jquery-extend-deep', 'shallow', 'shallow-assign'\n * @param {boolean} [options.removeMeta] - will force clones and strip $loki and meta properties from documents\n *\n * @returns {Array} An array of documents representing the current DynamicView contents.\n */\n data(options?: ResultSet.DataOptions): Doc[];\n /**\n * When the view is not sorted we may still wish to be notified of rebuild events.\n * This event will throttle and queue a single rebuild event when batches of updates affect the view.\n */\n private _queueRebuildEvent();\n /**\n * If the view is sorted we will throttle sorting to either :\n * (1) passive - when the user calls data(), or\n * (2) active - once they stop updating and yield js thread control\n */\n private _queueSortPhase();\n /**\n * Invoked synchronously or asynchronously to perform final sort phase (if needed)\n */\n private _performSortPhase(options?);\n /**\n * (Re)evaluating document inclusion.\n * Called by : collection.insert() and collection.update().\n * @param {int} objIndex - index of document to (re)run through filter pipeline.\n * @param {boolean} isNew - true if the document was just added to the collection.\n * @hidden\n */\n _evaluateDocument(objIndex: number, isNew: boolean): void;\n /**\n * Internal function called on collection.delete().\n * @hidden\n */\n _removeDocument(objIndex: number): void;\n /**\n * Data transformation via user supplied functions\n * @param {function} mapFunction - this function accepts a single document for you to transform and return\n * @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value\n * @returns The output of your reduceFunction\n */\n mapReduce(mapFunction: (item: T, index: number, array: T[]) => U1, reduceFunction: (array: U1[]) => U2): U2;\n}\nexport declare namespace DynamicView {\n interface Options {\n persistent?: boolean;\n sortPriority?: SortPriority;\n minRebuildInterval?: number;\n }\n type SortPriority = \"passive\" | \"active\";\n interface Serialized {\n name: string;\n _persistent: boolean;\n _sortPriority: SortPriority;\n _minRebuildInterval: number;\n _resultSet: ResultSet;\n _filterPipeline: Filter[];\n _sortCriteria: (string | [string, boolean])[];\n _sortCriteriaSimple: {\n field: string;\n options: boolean | ResultSet.SimpleSortOptions;\n };\n _sortByScoring: boolean;\n _sortDirty: boolean;\n }\n type Filter = {\n type: \"find\";\n val: ResultSet.Query>;\n uid: number | string;\n } | {\n type: \"where\";\n val: (obj: Doc) => boolean;\n uid: number | string;\n };\n}\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/event_emitter.d.ts",
"content": "/**\n * LokiEventEmitter is a minimalist version of EventEmitter. It enables any\n * constructor that inherits EventEmitter to emit events and trigger\n * listeners that have been added to the event through the on(event, callback) method\n *\n * @constructor LokiEventEmitter\n */\nexport declare class LokiEventEmitter {\n /**\n * A map, with each property being an array of callbacks.\n */\n protected _events: object;\n /**\n * Determines whether or not the callbacks associated with each event should happen in an async fashion or not.\n * Default is false, which means events are synchronous\n */\n protected _asyncListeners: boolean;\n /**\n * Adds a listener to the queue of callbacks associated to an event\n * @param {string|string[]} eventName - the name(s) of the event(s) to listen to\n * @param {function} listener - callback function of listener to attach\n * @returns {int} the index of the callback in the array of listeners for a particular event\n */\n on(eventName: string | string[], listener: Function): Function;\n /**\n * Emits a particular event\n * with the option of passing optional parameters which are going to be processed by the callback\n * provided signatures match (i.e. if passing emit(event, arg0, arg1) the listener should take two parameters)\n * @param {string} eventName - the name of the event\n * @param {object} data - optional object passed with the event\n */\n protected emit(eventName: string, ...data: any[]): void;\n /**\n * Alias of EventEmitter.on().\n */\n addListener(eventName: string | string[], listener: Function): Function;\n /**\n * Removes the listener at position 'index' from the event 'eventName'\n * @param {string|string[]} eventName - the name(s) of the event(s) which the listener is attached to\n * @param {function} listener - the listener callback function to remove from emitter\n */\n removeListener(eventName: string | string[], listener: Function): void;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/index.d.ts",
"content": "import { Loki } from \"./loki\";\nimport { Collection } from \"./collection\";\nexport { Loki, Collection };\nexport default Loki;\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/loki.d.ts",
"content": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { Collection } from \"./collection\";\nimport { Doc, StorageAdapter } from \"../../common/types\";\nimport { IComparatorMap } from \"./comparators\";\nimport { IRangedIndexFactoryMap } from \"./ranged_indexes\";\nimport { ILokiOperatorPackageMap } from \"./operator_packages\";\nexport declare class Loki extends LokiEventEmitter {\n filename: string;\n private databaseVersion;\n private engineVersion;\n _collections: Collection[];\n private _env;\n private _serializationMethod;\n private _destructureDelimiter;\n private _persistenceMethod;\n private _persistenceAdapter;\n private _throttledSaves;\n private _throttledSaveRunning;\n private _throttledSavePending;\n private _autosave;\n private _autosaveInterval;\n private _autosaveRunning;\n private _autosaveHandler;\n /**\n * Constructs the main database class.\n * @param {string} filename - name of the file to be saved to\n * @param {object} [options={}] - options\n * @param {Loki.Environment} [options.env] - the javascript environment\n * @param {Loki.SerializationMethod} [options.serializationMethod=NORMAL] - the serialization method\n * @param {string} [options.destructureDelimiter=\"$<\\n\"] - string delimiter used for destructured serialization\n * @param {IComparatorMap} [options.comparatorMap] allows injecting or overriding registered comparators\n * @param {IRangedIndexFactoryMap} [options.rangedIndexFactoryMap] allows injecting or overriding registered ranged index factories\n * @param {ILokiOperatorPackageMap} [options.lokiOperatorPackageMap] allows injecting or overriding registered loki operator packages\n */\n constructor(filename?: string, options?: Loki.Options);\n /**\n * configures options related to database persistence.\n *\n * @param {Loki.PersistenceOptions} [options={}] - options\n * @param {adapter} [options.adapter=auto] - an instance of a loki persistence adapter\n * @param {boolean} [options.autosave=false] - enables autosave\n * @param {int} [options.autosaveInterval=5000] - time interval (in milliseconds) between saves (if dirty)\n * @param {boolean} [options.autoload=false] - enables autoload on loki instantiation\n * @param {object} options.inflate - options that are passed to loadDatabase if autoload enabled\n * @param {boolean} [options.throttledSaves=true] - if true, it batches multiple calls to to saveDatabase reducing number of\n * disk I/O operations and guaranteeing proper serialization of the calls. Default value is true.\n * @param {Loki.PersistenceMethod} options.persistenceMethod - a persistence method which should be used (FS_STORAGE, LOCAL_STORAGE...)\n * @returns {Promise} a Promise that resolves after initialization and (if enabled) autoloading the database\n */\n initializePersistence(options?: Loki.PersistenceOptions): Promise;\n /**\n * Copies 'this' database into a new Loki instance. Object references are shared to make lightweight.\n * @param {object} options - options\n * @param {boolean} options.removeNonSerializable - nulls properties not safe for serialization.\n */\n copy(options?: Loki.CopyOptions): Loki;\n /**\n * Adds a collection to the database.\n * @param {string} name - name of collection to add\n * @param {object} [options={}] - options to configure collection with.\n * @param {array} [options.unique=[]] - array of property names to define unique constraints for\n * @param {array} [options.exact=[]] - array of property names to define exact constraints for\n * @param {array} [options.indices=[]] - array property names to define binary indexes for\n * @param {boolean} [options.asyncListeners=false] - whether listeners are called asynchronously\n * @param {boolean} [options.disableMeta=false] - set to true to disable meta property on documents\n * @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes Api\n * @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)\n * @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user\n * @param {string} [options.cloneMethod=CloneMethod.DEEP] - the clone method\n * @param {number} [options.ttl=] - age of document (in ms.) before document is considered aged/stale\n * @param {number} [options.ttlInterval=] - time interval for clearing out 'aged' documents; not set by default\n * @returns {Collection} a reference to the collection which was just added\n */\n addCollection(name: string, options?: Collection.Options): Collection;\n loadCollection(collection: Collection): void;\n /**\n * Retrieves reference to a collection by name.\n * @param {string} name - name of collection to look up\n * @returns {Collection} Reference to collection in database by that name, or null if not found\n */\n getCollection(name: string): Collection;\n /**\n * Renames an existing loki collection\n * @param {string} oldName - name of collection to rename\n * @param {string} newName - new name of collection\n * @returns {Collection} reference to the newly renamed collection\n */\n renameCollection(oldName: string, newName: string): Collection;\n listCollections(): {\n name: string;\n count: number;\n }[];\n /**\n * Removes a collection from the database.\n * @param {string} collectionName - name of collection to remove\n */\n removeCollection(collectionName: string): void;\n /**\n * Serialize database to a string which can be loaded via {@link Loki#loadJSON}\n *\n * @returns {string} Stringified representation of the loki database.\n */\n serialize(options?: Loki.SerializeOptions): string | string[];\n toJSON(): Loki.Serialized;\n /**\n * Database level destructured JSON serialization routine to allow alternate serialization methods.\n * Internally, Loki supports destructuring via loki \"serializationMethod' option and\n * the optional LokiPartitioningAdapter class. It is also available if you wish to do\n * your own structured persistence or data exchange.\n *\n * @param {object} options - output format options for use externally to loki\n * @param {boolean} [options.partitioned=false] - whether db and each collection are separate\n * @param {int} options.partition - can be used to only output an individual collection or db (-1)\n * @param {boolean} [options.delimited=true] - whether subitems are delimited or subarrays\n * @param {string} options.delimiter - override default delimiter\n *\n * @returns {string|Array} A custom, restructured aggregation of independent serializations.\n */\n serializeDestructured(options?: Loki.SerializeDestructuredOptions): string | string[];\n /**\n * Collection level utility method to serialize a collection in a 'destructured' format\n *\n * @param {object} options - used to determine output of method\n * @param {int} options.delimited - whether to return single delimited string or an array\n * @param {string} options.delimiter - (optional) if delimited, this is delimiter to use\n * @param {int} options.collectionIndex - specify which collection to serialize data for\n *\n * @returns {string|array} A custom, restructured aggregation of independent serializations for a single collection.\n */\n serializeCollection(options?: {\n delimited?: boolean;\n collectionIndex?: number;\n delimiter?: string;\n }): string | string[];\n /**\n * Database level destructured JSON deserialization routine to minimize memory overhead.\n * Internally, Loki supports destructuring via loki \"serializationMethod' option and\n * the optional LokiPartitioningAdapter class. It is also available if you wish to do\n * your own structured persistence or data exchange.\n *\n * @param {string|array} destructuredSource - destructured json or array to deserialize from\n * @param {object} options - source format options\n * @param {boolean} [options.partitioned=false] - whether db and each collection are separate\n * @param {int} options.partition - can be used to deserialize only a single partition\n * @param {boolean} [options.delimited=true] - whether subitems are delimited or subarrays\n * @param {string} options.delimiter - override default delimiter\n *\n * @returns {object|array} An object representation of the deserialized database, not yet applied to 'this' db or document array\n */\n deserializeDestructured(destructuredSource: string | string[], options?: Loki.SerializeDestructuredOptions): any;\n /**\n * Collection level utility function to deserializes a destructured collection.\n *\n * @param {string|string[]} destructuredSource - destructured representation of collection to inflate\n * @param {object} options - used to describe format of destructuredSource input\n * @param {int} [options.delimited=false] - whether source is delimited string or an array\n * @param {string} options.delimiter - if delimited, this is delimiter to use (if other than default)\n *\n * @returns {Array} an array of documents to attach to collection.data.\n */\n deserializeCollection(destructuredSource: string | string[], options?: Loki.DeserializeCollectionOptions): Doc[];\n /**\n * Inflates a loki database from a serialized JSON string\n *\n * @param {string} serializedDb - a serialized loki database string\n * @param {object} options - apply or override collection level settings\n * @param {boolean} options.retainDirtyFlags - whether collection dirty flags will be preserved\n */\n loadJSON(serializedDb: string | string[], options?: Collection.DeserializeOptions): void;\n /**\n * Inflates a loki database from a JS object\n *\n * @param {object} dbObject - a serialized loki database object\n * @param {object} options - apply or override collection level settings\n * @param {boolean} options.retainDirtyFlags - whether collection dirty flags will be preserved\n */\n loadJSONObject(dbObject: Loki, options?: Collection.DeserializeOptions): void;\n loadJSONObject(dbObject: Loki.Serialized, options?: Collection.DeserializeOptions): void;\n /**\n * Emits the close event. In autosave scenarios, if the database is dirty, this will save and disable timer.\n * Does not actually destroy the db.\n *\n * @returns {Promise} a Promise that resolves after closing the database succeeded\n */\n close(): Promise;\n /**-------------------------+\n | Changes API |\n +--------------------------*/\n /**\n * The Changes API enables the tracking the changes occurred in the collections since the beginning of the session,\n * so it's possible to create a differential dataset for synchronization purposes (possibly to a remote db)\n */\n /**\n * (Changes API) : takes all the changes stored in each\n * collection and creates a single array for the entire database. If an array of names\n * of collections is passed then only the included collections will be tracked.\n *\n * @param {Array} [arrayOfCollectionNames=] - array of collection names. No arg means all collections are processed.\n * @returns {Array} array of changes\n * @see private method _createChange() in Collection\n */\n generateChangesNotification(arrayOfCollectionNames?: string[]): Collection.Change[];\n /**\n * (Changes API) - stringify changes for network transmission\n * @returns {string} string representation of the changes\n */\n serializeChanges(collectionNamesArray?: string[]): string;\n /**\n * (Changes API) : clears all the changes in all collections.\n */\n clearChanges(): void;\n /**\n * Wait for throttledSaves to complete and invoke your callback when drained or duration is met.\n *\n * @param {object} options - configuration options\n * @param {boolean} [options.recursiveWait=true] - if after queue is drained, another save was kicked off, wait for it\n * @param {boolean} [options.recursiveWaitLimit=false] - limit our recursive waiting to a duration\n * @param {number} [options.recursiveWaitLimitDuration=2000] - cutoff in ms to stop recursively re-draining\n * @param {Date} [options.started=now()] - the start time of the recursive wait duration\n * @returns {Promise} a Promise that resolves when save queue is drained, it is passed a sucess parameter value\n */\n throttledSaveDrain(options?: Loki.ThrottledDrainOptions): Promise;\n /**\n * Internal load logic, decoupled from throttling/contention logic\n *\n * @param {object} options - an object containing inflation options for each collection\n * @param {boolean} ignore_not_found - does not raise an error if database is not found\n * @returns {Promise} a Promise that resolves after the database is loaded\n */\n private _loadDatabase(options?, ignore_not_found?);\n /**\n * Handles manually loading from an adapter storage (such as fs-storage)\n * This method utilizes loki configuration options (if provided) to determine which\n * persistence method to use, or environment detection (if configuration was not provided).\n * To avoid contention with any throttledSaves, we will drain the save queue first.\n *\n * If you are configured with autosave, you do not need to call this method yourself.\n *\n * @param {object} [options={}] - if throttling saves and loads, this controls how we drain save queue before loading\n * @param {boolean} [options.recursiveWait=true] wait recursively until no saves are queued\n * @param {boolean} [options.recursiveWaitLimit=false] limit our recursive waiting to a duration\n * @param {number} [options.recursiveWaitLimitDelay=2000] cutoff in ms to stop recursively re-draining\n * @param {Date} [options.started=now()] - the start time of the recursive wait duration\n * @returns {Promise} a Promise that resolves after the database is loaded\n */\n loadDatabase(options?: Loki.LoadDatabaseOptions): Promise;\n private _saveDatabase();\n /**\n * Handles manually saving to an adapter storage (such as fs-storage)\n * This method utilizes loki configuration options (if provided) to determine which\n * persistence method to use, or environment detection (if configuration was not provided).\n *\n * If you are configured with autosave, you do not need to call this method yourself.\n *\n * @returns {Promise} a Promise that resolves after the database is persisted\n */\n saveDatabase(): Promise;\n /**\n * Handles deleting a database from the underlying storage adapter\n *\n * @returns {Promise} a Promise that resolves after the database is deleted\n */\n deleteDatabase(): Promise;\n /****************\n * Autosave API\n ****************/\n /**\n * Check whether any collections are \"dirty\" meaning we need to save the (entire) database\n * @returns {boolean} - true if database has changed since last autosave, otherwise false\n */\n private _autosaveDirty();\n /**\n * Resets dirty flags on all collections.\n */\n private _autosaveClearFlags();\n /**\n * Starts periodically saves to the underlying storage adapter.\n */\n private _autosaveEnable();\n /**\n * Stops the autosave interval timer.\n */\n private _autosaveDisable();\n}\nexport declare namespace Loki {\n interface Options {\n env?: Environment;\n serializationMethod?: SerializationMethod;\n destructureDelimiter?: string;\n comparatorMap?: IComparatorMap;\n rangedIndexFactoryMap?: IRangedIndexFactoryMap;\n lokiOperatorPackageMap?: ILokiOperatorPackageMap;\n }\n interface PersistenceOptions {\n adapter?: StorageAdapter;\n autosave?: boolean;\n autosaveInterval?: number;\n autoload?: boolean;\n throttledSaves?: boolean;\n persistenceMethod?: Loki.PersistenceMethod;\n inflate?: any;\n }\n interface CopyOptions {\n removeNonSerializable?: boolean;\n }\n interface SerializeOptions {\n serializationMethod?: SerializationMethod;\n }\n interface SerializeDestructuredOptions {\n partitioned?: boolean;\n partition?: number;\n delimited?: boolean;\n delimiter?: string;\n }\n interface DeserializeCollectionOptions {\n partitioned?: boolean;\n delimited?: boolean;\n delimiter?: string;\n }\n interface ThrottledDrainOptions {\n recursiveWait?: boolean;\n recursiveWaitLimit?: boolean;\n recursiveWaitLimitDuration?: number;\n started?: Date;\n }\n interface Serialized {\n _env: Environment;\n _serializationMethod: SerializationMethod;\n _autosave: boolean;\n _autosaveInterval: number;\n _collections: Collection[];\n databaseVersion: number;\n engineVersion: number;\n filename: string;\n _persistenceAdapter: StorageAdapter;\n _persistenceMethod: PersistenceMethod;\n _throttledSaves: boolean;\n }\n type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrainOptions;\n type SerializationMethod = \"normal\" | \"pretty\" | \"destructured\";\n type PersistenceMethod = \"fs-storage\" | \"local-storage\" | \"indexed-storage\" | \"memory-storage\" | \"adapter\";\n type Environment = \"NATIVESCRIPT\" | \"NODEJS\" | \"CORDOVA\" | \"BROWSER\" | \"MEMORY\";\n}\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/operator_packages.d.ts",
"content": "import { ILokiComparer } from \"./comparators\";\n/** Hash interface for named LokiOperatorPackage registration */\nexport interface ILokiOperatorPackageMap {\n [name: string]: LokiOperatorPackage;\n}\n/**\n * Helper function for determining 'loki' abstract equality which is a little more abstract than ==\n * aeqHelper(5, '5') === true\n * aeqHelper(5.0, '5') === true\n * aeqHelper(new Date(\"1/1/2011\"), new Date(\"1/1/2011\")) === true\n * aeqHelper({a:1}, {z:4}) === true (all objects sorted equally)\n * aeqHelper([1, 2, 3], [1, 3]) === false\n * aeqHelper([1, 2, 3], [1, 2, 3]) === true\n * aeqHelper(undefined, null) === true\n * @param {any} prop1\n * @param {any} prop2\n * @returns {boolean}\n * @hidden\n */\nexport declare function aeqHelper(prop1: any, prop2: any): boolean;\n/**\n * Helper function for determining 'less-than' conditions for ops, sorting, and binary indices.\n * In the future we might want $lt and $gt ops to use their own functionality/helper.\n * Since binary indices on a property might need to index [12, NaN, new Date(), Infinity], we\n * need this function (as well as gtHelper) to always ensure one value is LT, GT, or EQ to another.\n * @hidden\n */\nexport declare function ltHelper(prop1: any, prop2: any, equal: boolean): boolean;\n/**\n * @hidden\n * @param {any} prop1\n * @param {any} prop2\n * @param {boolean} equal\n * @returns {boolean}\n */\nexport declare function gtHelper(prop1: any, prop2: any, equal: boolean): boolean;\n/**\n * @param {any} prop1\n * @param {any} prop2\n * @param {boolean} descending\n * @returns {number}\n * @hidden\n */\nexport declare function sortHelper(prop1: any, prop2: any, descending: boolean): number;\n/**\n * Default implementation of LokiOperatorPackage, using fastest javascript comparison operators.\n */\nexport declare class LokiOperatorPackage {\n $eq(a: any, b: any): boolean;\n $ne(a: any, b: any): boolean;\n $gt(a: any, b: any): boolean;\n $gte(a: any, b: any): boolean;\n $lt(a: any, b: any): boolean;\n $lte(a: any, b: any): boolean;\n $between(a: any, range: [any, any]): boolean;\n $in(a: any, b: any): boolean;\n $nin(a: any, b: any): boolean;\n $keyin(a: string, b: object): boolean;\n $nkeyin(a: string, b: object): boolean;\n $definedin(a: string, b: object): boolean;\n $undefinedin(a: string, b: object): boolean;\n $regex(a: string, b: RegExp): boolean;\n $containsNone(a: any, b: any): boolean;\n $containsAny(a: any, b: any): boolean;\n $contains(a: any, b: any): boolean;\n $type(a: any, b: any): boolean;\n $finite(a: number, b: boolean): boolean;\n $size(a: any, b: any): boolean;\n $len(a: any, b: any): boolean;\n $where(a: any, b: any): boolean;\n $not(a: any, b: any): boolean;\n $and(a: any, b: any): boolean;\n $or(a: any, b: any): boolean;\n private doQueryOp(val, op);\n private containsCheckFn(a);\n}\n/**\n * LokiOperatorPackage which utilizes abstract 'loki' comparisons for basic relational equality op implementations.\n */\nexport declare class LokiAbstractOperatorPackage extends LokiOperatorPackage {\n constructor();\n $eq(a: any, b: any): boolean;\n $ne(a: any, b: any): boolean;\n $gt(a: any, b: any): boolean;\n $gte(a: any, b: any): boolean;\n $lt(a: any, b: any): boolean;\n $lte(a: any, b: any): boolean;\n $between(a: any, range: [any, any]): boolean;\n}\n/**\n * LokiOperatorPackage which utilizes provided comparator for basic relational equality op implementations.\n */\nexport declare class ComparatorOperatorPackage extends LokiOperatorPackage {\n comparator: ILokiComparer;\n constructor(comparator: ILokiComparer);\n $eq(a: any, b: any): boolean;\n $ne(a: any, b: any): boolean;\n $gt(a: any, b: any): boolean;\n $gte(a: any, b: any): boolean;\n $lt(a: any, b: any): boolean;\n $lte(a: any, b: any): boolean;\n $between(a: any, range: [any, any]): boolean;\n}\n/**\n * Map/Register of named LokiOperatorPackages which implement all unindexed query ops within 'find' query objects\n */\nexport declare let LokiOperatorPackageMap: ILokiOperatorPackageMap;\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/ranged_indexes.d.ts",
"content": "import { ILokiComparer } from \"./comparators\";\nexport declare type RangedValueOperator = \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\" | \"$eq\" | \"$neq\" | \"$between\";\nexport interface IRangedIndexRequest {\n op: RangedValueOperator;\n val: T;\n high?: T;\n}\n/** Defines interface which all loki ranged indexes need to implement */\nexport interface IRangedIndex {\n insert(id: number, val: T): void;\n update(id: number, val: T): void;\n remove(id: number): void;\n restore(tree: any): void;\n backup(): IRangedIndex;\n rangeRequest(range?: IRangedIndexRequest): number[];\n validateIndex(): boolean;\n}\n/** Hash Interface for global ranged index factory map*/\nexport interface IRangedIndexFactoryMap {\n [name: string]: (name: string, comparator: ILokiComparer) => IRangedIndex;\n}\n/** Map/Register of named factory functions returning IRangedIndex instances */\nexport declare let RangedIndexFactoryMap: IRangedIndexFactoryMap;\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/result_set.d.ts",
"content": "import { Collection } from \"./collection\";\nimport { CloneMethod } from \"./clone\";\nimport { Doc } from \"../../common/types\";\nimport { Scorer } from \"../../full-text-search/src/scorer\";\nimport { Query as FullTextSearchQuery } from \"../../full-text-search/src/query_types\";\n/**\n * ResultSet class allowing chainable queries. Intended to be instanced internally.\n * Collection.find(), Collection.where(), and Collection.chain() instantiate this.\n *\n * @example\n * mycollection.chain()\n * .find({ 'doors' : 4 })\n * .where(function(obj) { return obj.name === 'Toyota' })\n * .data();\n *\n * @param - the data type\n * @param - nested properties of data type\n */\nexport declare class ResultSet {\n _collection: Collection;\n _filteredRows: number[];\n _filterInitialized: boolean;\n private _scoring;\n /**\n * Constructor.\n * @param {Collection} collection - the collection which this ResultSet will query against\n */\n constructor(collection: Collection);\n /**\n * Reset the ResultSet to its initial state.\n * @returns {ResultSet} Reference to this ResultSet, for future chain operations.\n */\n reset(): this;\n /**\n * Override of toJSON to avoid circular references\n */\n toJSON(): ResultSet;\n /**\n * Allows you to limit the number of documents passed to next chain operation.\n * A ResultSet copy() is made to avoid altering original ResultSet.\n * @param {int} qty - The number of documents to return.\n * @returns {ResultSet} Returns a copy of the ResultSet, limited by qty, for subsequent chain ops.\n */\n limit(qty: number): this;\n /**\n * Used for skipping 'pos' number of documents in the ResultSet.\n * @param {int} pos - Number of documents to skip; all preceding documents are filtered out.\n * @returns {ResultSet} Returns a copy of the ResultSet, containing docs starting at 'pos' for subsequent chain ops.\n */\n offset(pos: number): this;\n /**\n * To support reuse of ResultSet in branched query situations.\n * @returns {ResultSet} Returns a copy of the ResultSet (set) but the underlying document references will be the same.\n */\n copy(): ResultSet;\n /**\n * Executes a named collection transform or raw array of transform steps against the ResultSet.\n * @param {(string|array)} transform - name of collection transform or raw transform array\n * @param {object} [parameters=] - object property hash of parameters, if the transform requires them.\n * @returns {ResultSet} either (this) ResultSet or a clone of of this ResultSet (depending on steps)\n */\n transform(transform: string | Collection.Transform[], parameters?: object): this;\n /**\n * User supplied compare function is provided two documents to compare. (chainable)\n * @example\n * rslt.sort(function(obj1, obj2) {\n * if (obj1.name === obj2.name) return 0;\n * if (obj1.name > obj2.name) return 1;\n * if (obj1.name < obj2.name) return -1;\n * });\n * @param {function} comparefun - A javascript compare function used for sorting.\n * @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.\n */\n sort(comparefun: (a: Doc, b: Doc) => number): this;\n /**\n * Simpler, loose evaluation for user to sort based on a property name. (chainable).\n * Sorting based on the same lt/gt helper functions used for binary indices.\n * @param {string} propname - name of property to sort by.\n * @param {boolean|object=} options - boolean for sort descending or options object\n * @param {boolean} [options.desc=false] - whether to sort descending\n * @param {string} [options.sortComparator] override default with name of comparator registered in ComparatorMap\n * @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.\n */\n simplesort(propname: keyof T, options?: boolean | ResultSet.SimpleSortOptions): this;\n /**\n * Allows sorting a ResultSet based on multiple columns.\n * @example\n * // to sort by age and then name (both ascending)\n * rs.compoundsort(['age', 'name']);\n * // to sort by age (ascending) and then by name (descending)\n * rs.compoundsort(['age', ['name', true]);\n * @param {array} properties - array of property names or subarray of [propertyname, isdesc] used evaluate sort order\n * @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.\n */\n compoundsort(properties: (keyof T | [keyof T, boolean])[]): this;\n /**\n * Helper function for compoundsort(), performing individual object comparisons\n * @param {Array} properties - array of property names, in order, by which to evaluate sort order\n * @param {object} obj1 - first object to compare\n * @param {object} obj2 - second object to compare\n * @returns {number} 0, -1, or 1 to designate if identical (sortwise) or which should be first\n */\n private _compoundeval(properties, obj1, obj2);\n /**\n * Sorts the ResultSet based on the last full-text-search scoring.\n * @param {boolean} [ascending=false] - sort ascending\n * @returns {ResultSet}\n */\n sortByScoring(ascending?: boolean): this;\n /**\n * Returns the scoring of the last full-text-search.\n * @returns {ScoreResult[]}\n */\n getScoring(): Scorer.ScoreResult[];\n /**\n * Oversee the operation of OR'ed query expressions.\n * OR'ed expression evaluation runs each expression individually against the full collection,\n * and finally does a set OR on each expression's results.\n * Each evaluation can utilize a binary index to prevent multiple linear array scans.\n * @param {array} expressionArray - array of expressions\n * @returns {ResultSet} this ResultSet for further chain ops.\n */\n findOr(expressionArray: ResultSet.Query>[]): this;\n $or(expressionArray: ResultSet.Query>[]): this;\n /**\n * Oversee the operation of AND'ed query expressions.\n * AND'ed expression evaluation runs each expression progressively against the full collection,\n * internally utilizing existing chained ResultSet functionality.\n * Only the first filter can utilize a binary index.\n * @param {array} expressionArray - array of expressions\n * @returns {ResultSet} this ResultSet for further chain ops.\n */\n findAnd(expressionArray: ResultSet.Query>[]): this;\n $and(expressionArray: ResultSet.Query>[]): this;\n /**\n * Used for querying via a mongo-style query object.\n *\n * @param {object} query - A mongo-style query object used for filtering current results.\n * @param {boolean} firstOnly - (Optional) Used by collection.findOne() - flag if this was invoked via findOne()\n * @returns {ResultSet} this ResultSet for further chain ops.\n */\n find(query?: ResultSet.Query>, firstOnly?: boolean): this;\n /**\n * Used for filtering via a javascript filter function.\n * @param {function} fun - A javascript function used for filtering current results by.\n * @returns {ResultSet} this ResultSet for further chain ops.\n */\n where(fun: (obj: Doc) => boolean): this;\n /**\n * Returns the number of documents in the ResultSet.\n * @returns {number} The number of documents in the ResultSet.\n */\n count(): number;\n /**\n * Terminates the chain and returns array of filtered documents\n * @param {object} options\n * @param {boolean} [options.forceClones] - Allows forcing the return of cloned objects even when\n * the collection is not configured for clone object.\n * @param {string} [options.forceCloneMethod] - Allows overriding the default or collection specified cloning method.\n * Possible values 'parse-stringify', 'deep', and 'shallow' and\n * @param {boolean} [options.removeMeta] - will force clones and strip $loki and meta properties from documents\n *\n * @returns {Array} Array of documents in the ResultSet\n */\n data(options?: ResultSet.DataOptions): Doc[];\n /**\n * Used to run an update operation on all documents currently in the ResultSet.\n * @param {function} updateFunction - User supplied updateFunction(obj) will be executed for each document object.\n * @returns {ResultSet} this ResultSet for further chain ops.\n */\n update(updateFunction: (obj: Doc) => Doc): this;\n /**\n * Removes all document objects which are currently in ResultSet from collection (as well as ResultSet)\n * @returns {ResultSet} this (empty) ResultSet for further chain ops.\n */\n remove(): this;\n /**\n * data transformation via user supplied functions\n *\n * @param {function} mapFunction - this function accepts a single document for you to transform and return\n * @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value\n * @returns {value} The output of your reduceFunction\n */\n mapReduce(mapFunction: (item: Doc, index: number, array: Doc[]) => U1, reduceFunction: (array: U1[]) => U2): U2;\n /**\n * Left joining two sets of data. Join keys can be defined or calculated properties\n * eqJoin expects the right join key values to be unique. Otherwise left data will be joined on the last joinData object with that key\n * @param {Array|ResultSet|Collection} joinData - Data array to join to.\n * @param {(string|function)} leftJoinKey - Property name in this result set to join on or a function to produce a value to join on\n * @param {(string|function)} rightJoinKey - Property name in the joinData to join on or a function to produce a value to join on\n * @param {function} [mapFun=] - a function that receives each matching pair and maps them into output objects - function(left,right){return joinedObject}\n * @param {object} [dataOptions=] - optional options to apply to data() calls for left and right sides\n * @param {boolean} dataOptions.removeMeta - allows removing meta before calling mapFun\n * @param {boolean} dataOptions.forceClones - forcing the return of cloned objects to your map object\n * @param {string} dataOptions.forceCloneMethod - allows overriding the default or collection specified cloning method\n * @returns {ResultSet} A ResultSet with data in the format [{left: leftObj, right: rightObj}]\n */\n eqJoin(joinData: Collection | ResultSet | any[], leftJoinKey: string | ((obj: any) => string), rightJoinKey: string | ((obj: any) => string), mapFun?: (left: any, right: any) => any, dataOptions?: ResultSet.DataOptions): ResultSet;\n /**\n * Applies a map function into a new collection for further chaining.\n * @param {function} mapFun - javascript map function\n * @param {object} [dataOptions=] - options to data() before input to your map function\n * @param {boolean} dataOptions.removeMeta - allows removing meta before calling mapFun\n * @param {boolean} dataOptions.forceClones - forcing the return of cloned objects to your map object\n * @param {string} dataOptions.forceCloneMethod - Allows overriding the default or collection specified cloning method\n * @return {ResultSet}\n */\n map(mapFun: (obj: Doc, index: number, array: Doc[]) => U, dataOptions?: ResultSet.DataOptions): ResultSet;\n}\nexport declare namespace ResultSet {\n interface DataOptions {\n forceClones?: boolean;\n forceCloneMethod?: CloneMethod;\n removeMeta?: boolean;\n }\n interface SimpleSortOptions {\n desc?: boolean;\n sortComparator?: string;\n }\n type ContainsHelperType = R extends string ? string | string[] : R extends any[] ? R[number] | R[number][] : R extends object ? keyof R | (keyof R)[] : never;\n type LokiOps = {\n $eq?: R;\n } | {\n $ne?: R;\n } | {\n $gt?: R;\n } | {\n $gte?: R;\n } | {\n $lt?: R;\n } | {\n $lte?: R;\n } | {\n $between?: [R, R];\n } | {\n $in?: R[];\n } | {\n $nin?: R[];\n } | {\n $keyin?: object;\n } | {\n $nkeyin?: object;\n } | {\n $definedin?: object;\n } | {\n $undefinedin?: object;\n } | {\n $regex?: RegExp | string | [string, string];\n } | {\n $containsNone?: ContainsHelperType;\n } | {\n $containsAny?: ContainsHelperType;\n } | {\n $contains?: ContainsHelperType;\n } | {\n $type?: string;\n } | {\n $finite?: boolean;\n } | {\n $size?: number;\n } | {\n $len?: number;\n } | {\n $where?: (val?: R) => boolean;\n };\n type Query = {\n [P in keyof T]?: LokiOps | T[P];\n } & {\n $and?: Query[];\n } & {\n $or?: Query[];\n } & {\n $fts?: FullTextSearchQuery;\n };\n}\n"
},
{
"path": "dist/packages/fs-storage/types/loki/src/unique_index.d.ts",
"content": "export declare class UniqueIndex {\n private _field;\n private _lokiMap;\n private _valMap;\n /**\n * Constructs an unique index object.\n * @param {string} propertyField - the property field to index\n */\n constructor(propertyField: string);\n /**\n * Sets a document's unique index.\n * @param {number} id loki id to associate with value\n * @param {*} value value to associate with id\n */\n set(id: number, value: any): void;\n /**\n * Returns the $loki id of an unique value.\n * @param {*} value the value to retrieve a loki id match for\n */\n get(value: any): number;\n /**\n * Updates a document's unique index.\n * @param {number} id (loki) id of document to update the value to\n * @param {*} value value to associate with loki id\n */\n update(id: number, value: any): void;\n /**\n * Removes an unique index.\n * @param {number} id (loki) id to remove from index\n */\n remove(id: number): void;\n /**\n * Clears the unique index.\n */\n clear(): void;\n}\n"
},
{
"path": "dist/packages/fs-storage/types/memory-storage/src/index.d.ts",
"content": "import { MemoryStorage } from \"./memory_storage\";\nexport { MemoryStorage };\nexport default MemoryStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/memory-storage/src/memory_storage.d.ts",
"content": "import { Dict, StorageAdapter } from \"../../common/types\";\n/**\n * An in-memory persistence adapter for an in-memory database.\n * This simple 'key/value' adapter is intended for unit testing and diagnostics.\n */\nexport declare class MemoryStorage implements StorageAdapter {\n hashStore: Dict<{\n savecount: number;\n lastsave: Date;\n value: string;\n }>;\n options: MemoryStorage.Options;\n /**\n * Registers the local storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the local storage as plugin.\n */\n static deregister(): void;\n /**\n * @param {object} options - memory storage options\n * @param {boolean} [options.asyncResponses=false] - whether callbacks are invoked asynchronously (default: false)\n * @param {int} [options.asyncTimeout=50] - timeout in ms to queue callbacks (default: 50)\n */\n constructor(options?: MemoryStorage.Options);\n /**\n * Loads a serialized database from its in-memory store.\n * (Loki persistence adapter interface function)\n *\n * @param {string} dbname - name of the database (filename/keyname)\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise;\n /**\n * Saves a serialized database to its in-memory store.\n * (Loki persistence adapter interface function)\n *\n * @param {string} dbname - name of the database (filename/keyname)\n * @param {string} dbstring - the database content\n * @returns {Promise} a Promise that resolves after the database was persisted\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * Deletes a database from its in-memory store.\n *\n * @param {string} dbname - name of the database (filename/keyname)\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n}\nexport declare namespace MemoryStorage {\n interface Options {\n asyncResponses?: boolean;\n asyncTimeout?: number;\n }\n}\n"
},
{
"path": "dist/packages/fs-storage/types/partitioning-adapter/src/index.d.ts",
"content": "import { PartitioningAdapter } from \"./partitioning_adapter\";\nexport { PartitioningAdapter };\nexport default PartitioningAdapter;\n"
},
{
"path": "dist/packages/fs-storage/types/partitioning-adapter/src/partitioning_adapter.d.ts",
"content": "import { Loki } from \"../../loki/src/loki\";\nimport { StorageAdapter } from \"../../common/types\";\n/**\n * An adapter for adapters. Converts a non reference mode adapter into a reference mode adapter\n * which can perform destructuring and partitioning. Each collection will be stored in its own key/save and\n * only dirty collections will be saved. If you turn on paging with default page size of 25megs and save\n * a 75 meg collection it should use up roughly 3 save slots (key/value pairs sent to inner adapter).\n * A dirty collection that spans three pages will save all three pages again\n * Paging mode was added mainly because Chrome has issues saving 'too large' of a string within a\n * single IndexedDB row. If a single document update causes the collection to be flagged as dirty, all\n * of that collection's pages will be written on next save.\n */\nexport declare class PartitioningAdapter implements StorageAdapter {\n mode: string;\n private _adapter;\n private _dbref;\n private _dbname;\n private _pageIterator;\n private _paging;\n private _pageSize;\n private _delimiter;\n private _dirtyPartitions;\n /**\n * Registers the partitioning adapter as plugin.\n */\n static register(): void;\n /**\n * Deregisters the partitioning storage as plugin.\n */\n static deregister(): void;\n /**\n * @param {object} adapter - reference to a 'non-reference' mode loki adapter instance.\n * @param {boolean} paging - (default: false) set to true to enable paging collection data.\n * @param {number} pageSize - (default : 25MB) you can use this to limit size of strings passed to inner adapter.\n * @param {string} delimiter - allows you to override the default delimiter\n */\n constructor(adapter: StorageAdapter, {paging, pageSize, delimiter}?: {\n paging?: boolean;\n pageSize?: number;\n delimiter?: string;\n });\n /**\n * Loads a database which was partitioned into several key/value saves.\n * (Loki persistence adapter interface function)\n *\n * @param {string} dbname - name of the database (filename/keyname)\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise;\n /**\n * Used to sequentially load each collection partition, one at a time.\n *\n * @param {int} partition - ordinal collection position to load next\n * @returns {Promise} a Promise that resolves after the next partition is loaded\n */\n private _loadNextPartition(partition);\n /**\n * Used to sequentially load the next page of collection partition, one at a time.\n *\n * @returns {Promise} a Promise that resolves after the next page is loaded\n */\n private _loadNextPage();\n /**\n * Saves a database by partioning into separate key/value saves.\n * (Loki 'reference mode' persistence adapter interface function)\n *\n * @param {string} dbname - name of the database (filename/keyname)\n * @param {object} dbref - reference to database which we will partition and save.\n * @returns {Promise} a Promise that resolves after the database was deleted\n *\n */\n exportDatabase(dbname: string, dbref: Loki): Promise;\n /**\n * Helper method used internally to save each dirty collection, one at a time.\n *\n * @returns {Promise} a Promise that resolves after the next partition is saved\n */\n private _saveNextPartition();\n /**\n * Helper method used internally to generate and save the next page of the current (dirty) partition.\n *\n * @returns {Promise} a Promise that resolves after the next partition is saved\n */\n private _saveNextPage();\n}\n"
},
{
"path": "dist/packages/full-text-search/lokidb.full-text-search.js",
"content": "(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"@lokidb/full-text-search\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"@lokidb/full-text-search\"] = factory();\n\telse\n\t\t{ root[\"@lokidb/full-text-search\"] = factory(); root[\"LokiFullTextSearch\"] = root[\"@lokidb/full-text-search\"].default; }\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// define __esModule on exports\n/******/ \t__webpack_require__.r = function(exports) {\n/******/ \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t}\n/******/ \t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t};\n/******/\n/******/ \t// create a fake namespace object\n/******/ \t// mode & 1: value is a module id, require it\n/******/ \t// mode & 2: merge all properties of value into the ns\n/******/ \t// mode & 4: return value when already ns object\n/******/ \t// mode & 8|1: behave like require\n/******/ \t__webpack_require__.t = function(value, mode) {\n/******/ \t\tif(mode & 1) value = __webpack_require__(value);\n/******/ \t\tif(mode & 8) return value;\n/******/ \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n/******/ \t\tvar ns = Object.create(null);\n/******/ \t\t__webpack_require__.r(ns);\n/******/ \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n/******/ \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n/******/ \t\treturn ns;\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 1);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return PLUGINS; });\nfunction getGlobal() {\n let glob;\n (function (global) {\n glob = global;\n })(global !== undefined && global || this);\n return glob;\n}\nfunction create() {\n const global = getGlobal();\n const sym = Symbol.for(\"LOKI\");\n if (global[sym] === undefined) {\n global[sym] = {};\n }\n return global[sym];\n}\n/**\n * @hidden\n */\nconst PLUGINS = create();\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(2)))\n\n/***/ }),\n/* 1 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n__webpack_require__.r(__webpack_exports__);\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/analyzer/tokenizer.ts\n/**\n * Splits a string at whitespace characters into tokens.\n * @param {string} value - the string\n * @returns {string[]} - the tokens\n */\nfunction whitespaceTokenizer(value) {\n return value.split(/[\\s]+/);\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/analyzer/token_filter.ts\n/**\n * Converts a token to lowercase.\n * @param {string} token - the token\n * @returns {string} - the lowercased token\n */\nfunction lowercaseTokenFilter(token) {\n return token.toLowerCase();\n}\n/**\n * Converts a token to uppercase.\n * @param {string} token - the token\n * @returns {string} - the uppercased token\n */\nfunction uppercaseTokenFilter(token) {\n return token.toUpperCase();\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/analyzer/analyzer.ts\n\n\n/**\n * Analyzes a given string.\n * @param {Analyzer} analyzer - the analyzer\n * @param {string} str - the string\n * @returns {string[]} - the tokens\n */\nfunction analyze(analyzer, str) {\n if (analyzer.char_filter) {\n for (let j = 0; j < analyzer.char_filter.length; j++) {\n str = analyzer.char_filter[j](str);\n }\n }\n const tokens = analyzer.tokenizer(str);\n if (analyzer.token_filter) {\n for (let i = 0; i < tokens.length; i++) {\n for (let k = 0; k < analyzer.token_filter.length; k++) {\n tokens[i] = analyzer.token_filter[k](tokens[i], i, tokens);\n }\n }\n }\n // Remove empty tokens.\n return tokens.filter((token) => token);\n}\n/**\n * An analyzer with the whitespace tokenizer and the lowercase token filter.\n */\nclass analyzer_StandardAnalyzer {\n constructor() {\n this.tokenizer = whitespaceTokenizer;\n this.token_filter = [lowercaseTokenFilter];\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/inverted_index.ts\n\n/**\n * Converts a string into an array of code points.\n * @param str - the string\n * @returns {number[]} to code points\n * @hidden\n */\nfunction toCodePoints(str) {\n const r = [];\n for (let i = 0; i < str.length;) {\n const chr = str.charCodeAt(i++);\n if (chr >= 0xD800 && chr <= 0xDBFF) {\n // surrogate pair\n const low = str.charCodeAt(i++);\n r.push(0x10000 + ((chr - 0xD800) << 10) | (low - 0xDC00));\n }\n else {\n // ordinary character\n r.push(chr);\n }\n }\n return r;\n}\n/**\n * Inverted index class handles featured text search for specific document fields.\n * @hidden\n */\nclass inverted_index_InvertedIndex {\n /**\n * @param {boolean} [options.store=true] - inverted index will be stored at serialization rather than rebuilt on load\n * @param {boolean} [options.optimizeChanges=true] - flag to store additional metadata inside the index for better\n * performance if an existing field is updated or removed\n * @param {Analyzer} [options.analyzer=] - the analyzer of this inverted index\n */\n constructor(options = {}) {\n this.docCount = 0;\n this.docStore = new Map();\n this.totalFieldLength = 0;\n this.root = new Map();\n ({\n store: this._store = true,\n optimizeChanges: this._optimizeChanges = true,\n analyzer: this.analyzer = new analyzer_StandardAnalyzer()\n } = options);\n }\n /**\n * Adds defined fields of a document to the inverted index.\n * @param {string} field - the field to add\n * @param {number} docId - the doc id of the field\n */\n insert(field, docId) {\n if (this.docStore.has(docId)) {\n throw Error(\"Field already added.\");\n }\n // Tokenize document field.\n const fieldTokens = analyze(this.analyzer, field);\n if (fieldTokens.length == 0) {\n // Add empty field at least to document store for query 'exists'.\n this.docStore.set(docId, { fieldLength: 0 });\n return;\n }\n this.totalFieldLength += fieldTokens.length;\n this.docCount += 1;\n this.docStore.set(docId, { fieldLength: fieldTokens.length });\n // Holds references to each index of a document.\n const indexRef = [];\n if (this._optimizeChanges) {\n Object.defineProperties(this.docStore.get(docId), {\n indexRef: { enumerable: false, configurable: true, writable: true, value: indexRef }\n });\n }\n // Iterate over all unique field terms.\n for (const token of new Set(fieldTokens)) {\n // Calculate term frequency.\n let tf = 0;\n for (let j = 0; j < fieldTokens.length; j++) {\n if (fieldTokens[j] === token) {\n ++tf;\n }\n }\n // Add term to index tree.\n let branch = this.root;\n for (const c of toCodePoints(token)) {\n let child = branch.get(c);\n if (child === undefined) {\n child = new Map();\n if (this._optimizeChanges) {\n child.pa = branch;\n }\n branch.set(c, child);\n }\n branch = child;\n }\n // Add term info to index leaf.\n if (branch.dc === undefined) {\n branch.dc = new Map();\n branch.df = 0;\n }\n branch.dc.set(docId, tf);\n branch.df += 1;\n // Store index leaf for deletion.\n indexRef.push(branch);\n }\n }\n /**\n * Removes all relevant terms of a document from the inverted index.\n * @param {number} docId - the document.\n */\n remove(docId) {\n if (!this.docStore.has(docId)) {\n return;\n }\n const docStore = this.docStore.get(docId);\n // Remove document.\n this.docStore.delete(docId);\n if (docStore.fieldLength === 0) {\n return;\n }\n this.docCount -= 1;\n // Reduce total field length.\n this.totalFieldLength -= docStore.fieldLength;\n if (this._optimizeChanges) {\n // Iterate over all term references.\n // Remove docId from docs and decrement document frequency.\n const indexRef = docStore.indexRef;\n for (let j = 0; j < indexRef.length; j++) {\n let index = indexRef[j];\n index.df -= 1;\n index.dc.delete(docId);\n // Check if no document is left for current tree.\n if (index.df === 0) {\n // Delete unused meta data of branch.\n delete index.df;\n delete index.dc;\n // Check for sub branches.\n if (index.size !== 0) {\n continue;\n }\n // Delete term branch if not used anymore.\n do {\n // Go tree upwards.\n const parent = index.pa;\n // Delete parent reference for preventing memory leak (cycle reference).\n delete index.pa;\n // Iterate over all children.\n for (const key of parent.keys()) {\n // Remove previous child form parent.\n if (parent.get(key) === index) {\n parent.delete(key);\n break;\n }\n }\n index = parent;\n } while (index.pa !== undefined && index.size === 0 && index.df === undefined);\n }\n }\n }\n else {\n this._remove(this.root, docId);\n }\n }\n /**\n * Gets the term index of a term.\n * @param {string} term - the term\n * @param {object} root - the term index to start from\n * @param {number} start - the position of the term string to start from\n * @return {object} - The term index or null if the term is not in the term tree.\n */\n static getTermIndex(term, root, start = 0) {\n if (start >= term.length) {\n return null;\n }\n for (let i = start; i < term.length; i++) {\n let child = root.get(term[i]);\n if (child === undefined) {\n return null;\n }\n root = child;\n }\n return root;\n }\n /**\n * Extends a term index to all available term leafs.\n * @param {object} idx - the term index to start from\n * @param {number[]} [term=[]] - the current term\n * @param {Array} termIndices - all extended indices with their term\n * @returns {Array} - Array with term indices and extension\n */\n static extendTermIndex(idx, term = [], termIndices = []) {\n if (idx.df !== undefined) {\n termIndices.push({ index: idx, term: term.slice() });\n }\n term.push(0);\n for (const child of idx) {\n term[term.length - 1] = child[0];\n inverted_index_InvertedIndex.extendTermIndex(child[1], term, termIndices);\n }\n term.pop();\n return termIndices;\n }\n /**\n * Serialize the inverted index.\n * @returns {{docStore: *, _fields: *, index: *}}\n */\n toJSON() {\n if (this._store) {\n return {\n _store: true,\n _optimizeChanges: this._optimizeChanges,\n docCount: this.docCount,\n docStore: [...this.docStore],\n totalFieldLength: this.totalFieldLength,\n root: inverted_index_InvertedIndex._serializeIndex(this.root)\n };\n }\n return {\n _store: false,\n _optimizeChanges: this._optimizeChanges,\n };\n }\n /**\n * Deserialize the inverted index.\n * @param {{docStore: *, _fields: *, index: *}} serialized - The serialized inverted index.\n * @param {Analyzer} analyzer[undefined] - an analyzer\n */\n static fromJSONObject(serialized, analyzer) {\n const invIdx = new inverted_index_InvertedIndex({\n store: serialized._store,\n optimizeChanges: serialized._optimizeChanges,\n analyzer: analyzer\n });\n if (serialized._store) {\n invIdx.docCount = serialized.docCount;\n invIdx.docStore = new Map(serialized.docStore);\n invIdx.totalFieldLength = serialized.totalFieldLength;\n invIdx.root = inverted_index_InvertedIndex._deserializeIndex(serialized.root);\n }\n if (invIdx._optimizeChanges) {\n invIdx._regenerate(invIdx.root, null);\n }\n return invIdx;\n }\n static _serializeIndex(idx) {\n const serialized = {};\n if (idx.dc !== undefined) {\n serialized.d = { df: idx.df, dc: [...idx.dc] };\n }\n if (idx.size === 0) {\n return serialized;\n }\n const keys = [];\n const values = [];\n for (const child of idx) {\n keys.push(child[0]);\n values.push(inverted_index_InvertedIndex._serializeIndex(child[1]));\n }\n serialized.k = keys;\n serialized.v = values;\n return serialized;\n }\n static _deserializeIndex(serialized) {\n const idx = new Map();\n if (serialized.k !== undefined) {\n for (let i = 0; i < serialized.k.length; i++) {\n idx.set(serialized.k[i], inverted_index_InvertedIndex._deserializeIndex(serialized.v[i]));\n }\n }\n if (serialized.d !== undefined) {\n idx.df = serialized.d.df;\n idx.dc = new Map(serialized.d.dc);\n }\n return idx;\n }\n /**\n * Set parent of to each index and regenerate the indexRef.\n * @param {Index} index - the index\n * @param {Index} parent - the parent\n */\n _regenerate(index, parent) {\n // Set parent.\n if (parent !== null) {\n index.pa = parent;\n }\n // Iterate over subtree.\n for (const child of index.values()) {\n this._regenerate(child, index);\n }\n if (index.dc !== undefined) {\n // Get documents of term.\n for (const docId of index.dc.keys()) {\n // Get document store at specific document/field.\n const ref = this.docStore.get(docId);\n if (ref.indexRef === undefined) {\n Object.defineProperties(ref, {\n indexRef: { enumerable: false, configurable: true, writable: true, value: [] }\n });\n }\n // Set reference to term index.\n ref.indexRef.push(index);\n }\n }\n }\n /**\n * Iterate over the whole inverted index and remove the document.\n * Delete branch if not needed anymore.\n * Function is needed if index is used without optimization.\n * @param {Index} idx - the index\n * @param {number} docId - the doc id\n * @returns {boolean} true if index is empty\n */\n _remove(idx, docId) {\n for (const child of idx) {\n // Checkout branch.\n if (this._remove(child[1], docId)) {\n idx.delete(child[0]);\n }\n }\n // Remove docId from docs and decrement document frequency.\n if (idx.df !== undefined) {\n if (idx.dc.has(docId)) {\n idx.df -= 1;\n idx.dc.delete(docId);\n // Delete unused meta data of branch.\n if (idx.df === 0) {\n delete idx.df;\n delete idx.dc;\n }\n }\n }\n return idx.size === 0 && idx.dc === undefined;\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/scorer.ts\n/**\n * @hidden\n */\nclass Scorer {\n constructor(invIdxs) {\n this._cache = {};\n this._invIdxs = invIdxs;\n }\n setDirty() {\n this._cache = {};\n }\n score(fieldName, boost, termIdx, doScoring, queryResults, term, df = 0) {\n if (termIdx === null || termIdx.dc === undefined) {\n return;\n }\n const idf = this._idf(fieldName, df || termIdx.df);\n for (const [docId, tf] of termIdx.dc) {\n if (!queryResults.has(docId)) {\n queryResults.set(docId, []);\n }\n if (doScoring === true) {\n // BM25 scoring.\n queryResults.get(docId).push({ tf, idf, boost, fieldName, term });\n }\n else if (doScoring === false) {\n // Constant scoring.\n queryResults.set(docId, [{ boost }]);\n }\n else {\n // Zero scoring.\n queryResults.set(docId, [{ boost: 0 }]);\n }\n }\n }\n scoreConstant(boost, docId, queryResults) {\n if (!queryResults.has(docId)) {\n queryResults.set(docId, []);\n }\n queryResults.get(docId).push({ boost });\n return queryResults;\n }\n finalScore(query, queryResults) {\n const finalResult = {};\n const k1 = query.bm25 !== undefined ? query.bm25.k1 : 1.2;\n const b = query.bm25 !== undefined ? query.bm25.b : 0.75;\n const explain = query.explain !== undefined ? query.explain : false;\n for (const [docId, result] of queryResults) {\n let docScore = 0;\n let docExplanation = [];\n for (let i = 0; i < result.length; i++) {\n const queryResult = result[i];\n let score = 0;\n if (queryResult.tf !== undefined) {\n // BM25 scoring.\n const tf = queryResult.tf;\n const fieldLength = Scorer._calculateFieldLength(this._invIdxs[queryResult.fieldName].docStore.get(docId)\n .fieldLength);\n const avgFieldLength = this._avgFieldLength(queryResult.fieldName);\n const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (fieldLength / avgFieldLength)));\n score = queryResult.idf * tfNorm * queryResult.boost;\n if (explain) {\n docExplanation.push({\n boost: queryResult.boost,\n score: score,\n docID: docId,\n fieldName: queryResult.fieldName,\n index: String.fromCharCode(...queryResult.term),\n idf: queryResult.idf,\n tfNorm: tfNorm,\n tf: tf,\n fieldLength: fieldLength,\n avgFieldLength: avgFieldLength,\n });\n }\n }\n else {\n // Constant scoring.\n score = queryResult.boost;\n if (explain) {\n docExplanation.push({\n boost: queryResult.boost,\n score: score\n });\n }\n }\n docScore += score;\n }\n if (explain) {\n finalResult[docId] = {\n score: docScore,\n explanation: docExplanation\n };\n }\n else {\n finalResult[docId] = {\n score: docScore\n };\n }\n }\n return finalResult;\n }\n static _calculateFieldLength(fieldLength) {\n // Dummy function to be compatible to lucene in unit tests.\n return fieldLength;\n }\n _getCache(fieldName) {\n if (this._cache[fieldName] === undefined) {\n const avgFieldLength = this._invIdxs[fieldName].totalFieldLength / this._invIdxs[fieldName].docCount;\n this._cache[fieldName] = { idfs: {}, avgFieldLength };\n }\n return this._cache[fieldName];\n }\n /**\n * Returns the idf by either calculate it or use a cached one.\n * @param {string} fieldName - the name of the field\n * @param {number} docFreq - the doc frequency of the term\n * @returns {number} the idf\n * @private\n */\n _idf(fieldName, docFreq) {\n const cache = this._getCache(fieldName);\n if (cache.idfs[docFreq] !== undefined) {\n return cache.idfs[docFreq];\n }\n return cache.idfs[docFreq] = Math.log(1 + (this._invIdxs[fieldName].docCount - docFreq + 0.5) / (docFreq + 0.5));\n }\n _avgFieldLength(fieldName) {\n return this._getCache(fieldName).avgFieldLength;\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/run_automaton.ts\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\nclass RunAutomaton {\n constructor(automaton) {\n const size = automaton.getNumStates();\n this._points = automaton.getStartPoints();\n this._accept = new Array(size);\n this._transitions = new Array(size * this._points.length);\n for (let n = 0; n < size; n++) {\n this._accept[n] = automaton.isAccept(n);\n for (let c = 0; c < this._points.length; c++) {\n // assert dest === -1 || dest < size;\n this._transitions[n * this._points.length + c] = automaton.step(n, this._points[c]);\n }\n }\n this._classmap = new Array(256 /* alphaSize */);\n for (let i = 0, j = 0; j < this._classmap.length; j++) {\n if (i + 1 < this._points.length && j === this._points[i + 1]) {\n i++;\n }\n this._classmap[j] = i;\n }\n }\n getCharClass(c) {\n // binary search\n let a = 0;\n let b = this._points.length;\n while (b - a > 1) {\n const d = (a + b) >>> 1;\n if (this._points[d] > c) {\n b = d;\n }\n else if (this._points[d] < c) {\n a = d;\n }\n else {\n return d;\n }\n }\n return a;\n }\n step(state, c) {\n if (c >= this._classmap.length) {\n return this._transitions[state * this._points.length + this.getCharClass(c)];\n }\n else {\n return this._transitions[state * this._points.length + this._classmap[c]];\n }\n }\n isAccept(state) {\n return this._accept[state];\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/automaton.ts\n/**\n * @type {number}\n * @hidden\n */\nconst MIN_CODE_POINT = 0;\n/**\n * @type {number}\n * @hidden\n */\nconst MAX_CODE_POINT = 1114111;\nfunction sortByDestMinMax(a, b) {\n if (a[0] < b[0]) {\n return -1;\n }\n else if (a[0] > b[0]) {\n return 1;\n }\n if (a[1] < b[1]) {\n return -1;\n }\n else if (a[1] > b[1]) {\n return 1;\n }\n if (a[2] < b[2]) {\n return -1;\n }\n else if (a[2] > b[2]) {\n return 1;\n }\n return 0;\n}\nfunction sortByMinMaxDest(a, b) {\n if (a[1] < b[1]) {\n return -1;\n }\n else if (a[1] > b[1]) {\n return 1;\n }\n if (a[2] < b[2]) {\n return -1;\n }\n else if (a[2] > b[2]) {\n return 1;\n }\n if (a[0] < b[0]) {\n return -1;\n }\n else if (a[0] > b[0]) {\n return 1;\n }\n return 0;\n}\n/**\n * From org/apache/lucene/util/automaton/Automaton.java\n * @hidden\n */\nclass Automaton {\n constructor() {\n this._stateTransitions = [];\n this._stateTransitions = [];\n this._accept = new Set();\n this._nextState = 0;\n this._currState = -1;\n // this.deterministic = true;\n this._transitions = {};\n }\n isAccept(n) {\n return this._accept.has(n);\n }\n createState() {\n return this._nextState++;\n }\n setAccept(state, accept) {\n if (accept) {\n this._accept.add(state);\n }\n else {\n this._accept.delete(state);\n }\n }\n finishState() {\n if (this._currState !== -1) {\n this._finishCurrentState();\n this._currState = -1;\n }\n }\n _finishCurrentState() {\n // Sort all transitions.\n this._stateTransitions.sort(sortByDestMinMax);\n let upto = 0;\n let p = [-1, -1, -1];\n for (let i = 0, len = this._stateTransitions.length; i < len; i++) {\n let t = this._stateTransitions[i];\n if (p[0] === t[0]) {\n if (t[1] <= p[2] + 1) {\n if (t[2] > p[2]) {\n p[2] = t[2];\n }\n }\n else {\n if (p[0] !== -1) {\n this._stateTransitions[upto][0] = p[0];\n this._stateTransitions[upto][1] = p[1];\n this._stateTransitions[upto][2] = p[2];\n upto++;\n }\n p[1] = t[1];\n p[2] = t[2];\n }\n }\n else {\n if (p[0] !== -1) {\n this._stateTransitions[upto][0] = p[0];\n this._stateTransitions[upto][1] = p[1];\n this._stateTransitions[upto][2] = p[2];\n upto++;\n }\n p[0] = t[0];\n p[1] = t[1];\n p[2] = t[2];\n }\n }\n if (p[0] !== -1) {\n // Last transition\n this._stateTransitions[upto][0] = p[0];\n this._stateTransitions[upto][1] = p[1];\n this._stateTransitions[upto][2] = p[2];\n upto++;\n }\n this._transitions[this._currState] = this._stateTransitions.slice(0, upto).sort(sortByMinMaxDest);\n // if (this.deterministic && upto > 1) {\n // let lastMax = this.stateTransitions[0][2];\n // for (let i = 1; i < upto; i++) {\n // let min = this.stateTransitions[i][1];\n // if (min <= lastMax) {\n // this.deterministic = false;\n // break;\n // }\n // lastMax = this.stateTransitions[i][2];\n // }\n // }\n this._stateTransitions = [];\n }\n getStartPoints() {\n const pointset = new Set();\n pointset.add(MIN_CODE_POINT);\n const states = Object.keys(this._transitions);\n for (let i = 0; i < states.length; i++) {\n let trans = this._transitions[states[i]];\n for (let j = 0; j < trans.length; j++) {\n let tran = trans[j];\n pointset.add(tran[1]);\n if (tran[2] < MAX_CODE_POINT) {\n pointset.add(tran[2] + 1);\n }\n }\n }\n return Array.from(pointset).sort((a, b) => a - b);\n }\n step(state, label) {\n let trans = this._transitions[state];\n if (trans) {\n for (let i = 0; i < trans.length; i++) {\n let tran = trans[i];\n if (tran[1] <= label && label <= tran[2]) {\n return tran[0];\n }\n }\n }\n return -1;\n }\n getNumStates() {\n return this._nextState;\n }\n addTransition(source, dest, min, max) {\n if (this._currState !== source) {\n if (this._currState !== -1) {\n this._finishCurrentState();\n }\n this._currState = source;\n }\n this._stateTransitions.push([dest, min, max]);\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/long.ts\n/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nclass Long {\n constructor(low = 0, high = 0) {\n this._low = low;\n this._high = high;\n }\n /**\n * Returns this long with bits arithmetically shifted to the right by the given amount.\n * @param {number} numBits - number of bits\n * @returns {Long} the long\n */\n shiftRight(numBits) {\n if ((numBits &= 63) === 0)\n return this;\n else if (numBits < 32)\n return new Long((this._low >>> numBits) | (this._high << (32 - numBits)), this._high >> numBits);\n else\n return new Long((this._high >> (numBits - 32)), this._high >= 0 ? 0 : -1);\n }\n /**\n * Returns this long with bits arithmetically shifted to the left by the given amount.\n * @param {number} numBits - number of bits\n * @returns {Long} the long\n */\n shiftLeft(numBits) {\n if ((numBits &= 63) === 0)\n return this;\n else if (numBits < 32)\n return new Long(this._low << numBits, (this._high << numBits) | (this._low >>> (32 - numBits)));\n else\n return new Long(0, this._low << (numBits - 32));\n }\n /**\n * Returns the bitwise AND of this Long and the specified.\n * @param {Long} other - the other Long\n * @returns {Long} the long\n */\n and(other) {\n return new Long(this._low & other._low, this._high & other._high);\n }\n /**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @returns {number}\n */\n toInt() {\n return this._low;\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/parametric_description.ts\n\nconst MASKS = [new Long(0x1), new Long(0x3), new Long(0x7), new Long(0xf),\n new Long(0x1f), new Long(0x3f), new Long(0x7f), new Long(0xff),\n new Long(0x1ff), new Long(0x3ff), new Long(0x7ff), new Long(0xfff),\n new Long(0x1fff), new Long(0x3fff), new Long(0x7fff), new Long(0xffff),\n new Long(0xf, 0x1fff), new Long(0xf, 0x3fff), new Long(0xf, 0x7fff), new Long(0xf, 0xffff),\n new Long(0xff, 0x1fff), new Long(0xff, 0x3fff), new Long(0xff, 0x7fff), new Long(0xff, 0xffff),\n new Long(0xfff, 0x1fff), new Long(0xfff, 0x3fff), new Long(0xfff, 0x7fff), new Long(0xfff, 0xffff),\n new Long(0xffff, 0x1fff), new Long(0xffff, 0x3fff), new Long(0xffff, 0x7fff), new Long(0xffff, 0xffff),\n new Long(0xfffff, 0x1fff), new Long(0xfffff, 0x3fff), new Long(0xfffff, 0x7fff), new Long(0xfffff, 0xffff),\n new Long(0xffffff, 0x1fff), new Long(0xffffff, 0x3fff), new Long(0xffffff, 0x7fff), new Long(0xffffff, 0xffff),\n new Long(0xfffffff, 0x1fff), new Long(0xfffffff, 0x3fff), new Long(0xfffffff, 0x7fff), new Long(0xfffffff, 0xffff),\n new Long(0xffffffff, 0x1fff), new Long(0xffffffff, 0x3fff), new Long(0xffffffff, 0x7fff), new Long(0xffffffff, 0xffff),\n new Long(0xfffffffff, 0x1fff), new Long(0xfffffffff, 0x3fff), new Long(0xfffffffff, 0x7fff), new Long(0xfffffffff, 0xffff),\n new Long(0xffffffffff, 0x1fff), new Long(0xffffffffff, 0x3fff), new Long(0xffffffffff, 0x7fff), new Long(0xffffffffff, 0xffff),\n new Long(0xfffffffffff, 0x1fff), new Long(0xfffffffffff, 0x3fff), new Long(0xfffffffffff, 0x7fff), new Long(0xfffffffffff, 0xffff),\n new Long(0xffffffffffff, 0x1fff), new Long(0xffffffffffff, 0x3fff), new Long(0xffffffffffff, 0x7fff)];\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescription\n * @hidden\n */\nclass ParametricDescription {\n constructor(w, n, minErrors) {\n this._w = w;\n this._n = n;\n this._minErrors = minErrors;\n }\n /**\n * Return the number of states needed to compute a Levenshtein DFA\n */\n size() {\n return this._minErrors.length * (this._w + 1);\n }\n /**\n * Returns true if the state in any Levenshtein DFA is an accept state (final state).\n */\n isAccept(absState) {\n // decode absState -> state, offset\n let state = Math.floor(absState / (this._w + 1));\n let offset = absState % (this._w + 1);\n //assert offset >= 0;\n return this._w - offset + this._minErrors[state] <= this._n;\n }\n /**\n * Returns the position in the input word for a given state.\n * This is the minimal boundary for the state.\n */\n getPosition(absState) {\n return absState % (this._w + 1);\n }\n static unpack(data, index, bitsPerValue) {\n const bitLoc = bitsPerValue * index;\n const dataLoc = (bitLoc >> 6);\n const bitStart = (bitLoc & 63);\n if (bitStart + bitsPerValue <= 64) {\n // not split\n return data[dataLoc].shiftRight(bitStart).and(MASKS[bitsPerValue - 1]).toInt();\n }\n else {\n // split\n const part = 64 - bitStart;\n return (data[dataLoc].shiftRight(bitStart).and(MASKS[part - 1])).toInt()\n + (data[1 + dataLoc].and(MASKS[bitsPerValue - part - 1]).shiftLeft(part)).toInt();\n }\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/lev1t_parametric_description.ts\n\n\n// 1 vectors; 2 states per vector; array length = 2\nconst toStates0 = [new Long(0x2)];\nconst offsetIncrs0 = [new Long(0x0)];\n// 2 vectors; 3 states per vector; array length = 6\nconst toStates1 = [new Long(0xa43)];\nconst offsetIncrs1 = [new Long(0x38)];\n// 4 vectors; 6 states per vector; array length = 24\nconst toStates2 = [new Long(0x82140003, 0x34534914), new Long(0x6d)];\nconst offsetIncrs2 = [new Long(0x55a20000, 0x5555)];\n// 8 vectors; 6 states per vector; array length = 48\nconst toStates3 = [new Long(0x900C0003, 0x21520854), new Long(0x4534916d, 0x5b4d19a2), new Long(0xda34)];\nconst offsetIncrs3 = [new Long(0x20fc0000, 0x5555ae0a), new Long(0x55555555)];\n// state map\n// 0 -> [(0, 0)]\n// 1 -> [(0, 1)]\n// 2 -> [(0, 1), (1, 1)]\n// 3 -> [(0, 1), (2, 1)]\n// 4 -> [t(0, 1), (0, 1), (1, 1), (2, 1)]\n// 5 -> [(0, 1), (1, 1), (2, 1)]\n/**\n * From org/apache/lucene/util/automaton/Lev1TParametricDescription.java\n * @hidden\n */\nclass lev1t_parametric_description_Lev1TParametricDescription extends ParametricDescription {\n constructor(w) {\n super(w, 1, [0, 1, 0, -1, -1, -1]);\n }\n transition(absState, position, vector) {\n // null absState should never be passed in\n //assert absState != -1;\n // decode absState -> state, offset\n let state = Math.floor(absState / (this._w + 1));\n let offset = absState % (this._w + 1);\n //assert offset >= 0;\n if (position === this._w) {\n if (state < 2) {\n const loc = vector * 2 + state;\n offset += ParametricDescription.unpack(offsetIncrs0, loc, 1);\n state = ParametricDescription.unpack(toStates0, loc, 2) - 1;\n }\n }\n else if (position === this._w - 1) {\n if (state < 3) {\n const loc = vector * 3 + state;\n offset += ParametricDescription.unpack(offsetIncrs1, loc, 1);\n state = ParametricDescription.unpack(toStates1, loc, 2) - 1;\n }\n }\n else if (position === this._w - 2) {\n if (state < 6) {\n const loc = vector * 6 + state;\n offset += ParametricDescription.unpack(offsetIncrs2, loc, 2);\n state = ParametricDescription.unpack(toStates2, loc, 3) - 1;\n }\n }\n else {\n if (state < 6) {\n const loc = vector * 6 + state;\n offset += ParametricDescription.unpack(offsetIncrs3, loc, 2);\n state = ParametricDescription.unpack(toStates3, loc, 3) - 1;\n }\n }\n if (state === -1) {\n // null state\n return -1;\n }\n else {\n // translate back to abs\n return state * (this._w + 1) + offset;\n }\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/lev2t_parametric_description.ts\n\n\n// 1 vectors; 3 states per vector; array length = 3\nconst lev2t_parametric_description_toStates0 = /*2 bits per value */ [\n new Long(0x23)\n];\nconst lev2t_parametric_description_offsetIncrs0 = /*1 bits per value */ [\n new Long(0x0)\n];\n// 2 vectors; 5 states per vector; array length = 10\nconst lev2t_parametric_description_toStates1 = /*3 bits per value */ [\n new Long(0x13688b44)\n];\nconst lev2t_parametric_description_offsetIncrs1 = /*1 bits per value */ [\n new Long(0x3e0)\n];\n// 4 vectors; 13 states per vector; array length = 52\nconst lev2t_parametric_description_toStates2 = /*4 bits per value */ [\n new Long(0x5200b504, 0x60dbb0b0), new Long(0x27062227, 0x52332176), new Long(0x14323235, 0x23555432), new Long(0x4354)\n];\nconst lev2t_parametric_description_offsetIncrs2 = /*2 bits per value */ [\n new Long(0x00002000, 0x555080a8), new Long(0x55555555, 0x55)\n];\n// 8 vectors; 28 states per vector; array length = 224\nconst lev2t_parametric_description_toStates3 = /*5 bits per value */ [\n new Long(0x40059404, 0xe701c029), new Long(0x00a50000, 0xa0101620), new Long(0xa1416288, 0xb02c8c40), new Long(0x310858c0, 0xa821032),\n new Long(0x0d28b201, 0x31442398), new Long(0x847788e0, 0x5281e528), new Long(0x08c2280e, 0xa23980d3), new Long(0xa962278c, 0x1e3294b1),\n new Long(0x2288e528, 0x8c41309e), new Long(0x021aca21, 0x11444409), new Long(0x86b1086b, 0x11a46248), new Long(0x1d6240c4, 0x2a625894),\n new Long(0x489074ad, 0x5024a50b), new Long(0x520c411a, 0x14821aca), new Long(0x0b594a44, 0x5888b589), new Long(0xc411a465, 0x941d6520),\n new Long(0xad6a62d4, 0x8b589075), new Long(0x1a5055a4)\n];\nconst lev2t_parametric_description_offsetIncrs3 = /*2 bits per value */ [\n new Long(0x00002000, 0x30c302), new Long(0xc3fc333c, 0x2a0030f3), new Long(0x8282a820, 0x233a0032), new Long(0x32b283a8, 0x55555555),\n new Long(0x55555555, 0x55555555), new Long(0x55555555, 0x55555555), new Long(0x55555555, 0x55555555)\n];\n// 16 vectors; 45 states per vector; array length = 720\nconst toStates4 = /*6 bits per value */ [\n new Long(0x002c5004, 0x3801450), new Long(0x00000e38, 0xc500014b), new Long(0x51401402, 0x514), new Long(0x0),\n new Long(0x14010000, 0x518000b), new Long(0x28e20230, 0x9f1c208), new Long(0x830a70c2, 0x219f0df0), new Long(0x08208200, 0x82000082),\n new Long(0x60800800, 0x8050501), new Long(0x02602643, 0x30820986), new Long(0x50508064, 0x45640142), new Long(0x20000831, 0x8500514),\n new Long(0x85002082, 0x41405820), new Long(0x0990c201, 0x45618098), new Long(0x50a01051, 0x8316d0c), new Long(0x050df0e0, 0x21451420),\n new Long(0x14508214, 0xd142140), new Long(0x50821c60, 0x3c21c018), new Long(0xcb142087, 0x1cb1403), new Long(0x1851822c, 0x80082145),\n new Long(0x20800020, 0x200208), new Long(0x87180345, 0xd0061820), new Long(0x24976b09, 0xcb0a81cb), new Long(0x624709d1, 0x8b1a60e),\n new Long(0x82249089, 0x2490820), new Long(0x00d2c024, 0xc31421c6), new Long(0x15454423, 0x3c314515), new Long(0xc21cb140, 0x31853c22),\n new Long(0x2c208214, 0x4514500b), new Long(0x508b0051, 0x8718034), new Long(0x5108f0c5, 0xb2cb4551), new Long(0x1cb0a810, 0xe824715d),\n new Long(0x908b0e60, 0x1422cb14), new Long(0xc02cb145, 0x30812c22), new Long(0x0cb1420c, 0x84202202), new Long(0x20ce0850, 0x5c20ce08),\n new Long(0x8b0d70c2, 0x20820820), new Long(0x14214208, 0x42085082), new Long(0x50830c20, 0x9208340), new Long(0x13653592, 0xc6134dc6),\n new Long(0x6dc4db4d, 0xd309341c), new Long(0x54d34d34, 0x6424d908), new Long(0x030814c2, 0x92072c22), new Long(0x24a30930, 0x4220724b),\n new Long(0x25c920e2, 0x2470d720), new Long(0x975c9082, 0x92c92d70), new Long(0x04924e08, 0xcb0880c2), new Long(0xc24c2481, 0x45739728),\n new Long(0xda6174da, 0xc6da4db5), new Long(0x5d30971d, 0x4b5d35d7), new Long(0x93825ce2, 0x1030815c), new Long(0x020cb145, 0x51442051),\n new Long(0x2c220e2c, 0xc538210e), new Long(0x52cb0d70, 0x8514214), new Long(0x85145142, 0x204b0850), new Long(0x4051440c, 0x92156083),\n new Long(0xa60e6595, 0x4d660e4d), new Long(0x1c6dc658, 0x94d914e4), new Long(0x1454d365, 0x82642659), new Long(0x51030813, 0x2892072c),\n new Long(0xcb2ca30b, 0xe2c22072), new Long(0x20538910, 0x452c70d7), new Long(0x708e3891, 0x8b2cb2d), new Long(0xc204b24e, 0x81cb1440),\n new Long(0x28c2ca24, 0xda44e38e), new Long(0x85d660e4, 0x1dc6da65), new Long(0x8e5d914e, 0xe2cb5d33), new Long(0x38938238)\n];\nconst offsetIncrs4 = /*3 bits per value */ [\n new Long(0x00080000, 0x30020000), new Long(0x20c060), new Long(0x04000000, 0x81490000), new Long(0x10824824, 0x40249241),\n new Long(0x60002082, 0xdb6030c3), new Long(0x301b0d80, 0x6c36c06c), new Long(0x000db0db, 0xb01861b0), new Long(0x9188e06d, 0x1b703620),\n new Long(0x06d86db7, 0x8009200), new Long(0x02402490, 0x4920c24), new Long(0x08249009, 0x490002), new Long(0x28124804, 0x49081281),\n new Long(0x124a44a2, 0x34800104), new Long(0x0d24020c, 0xc3093090), new Long(0x24c24d24, 0x40009a09), new Long(0x9201061a, 0x4984a06),\n new Long(0x71269262, 0x494d0492), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x2492)\n];\n// 32 vectors; 45 states per vector; array length = 1440\nconst toStates5 = /*6 bits per value */ [\n new Long(0x002c5004, 0x3801450), new Long(0x00000e38, 0xc500014b), new Long(0x51401402, 0x514), new Long(0x0),\n new Long(0x14010000, 0x514000b), new Long(0x038e00e0, 0x550000), new Long(0x0600b180, 0x26451850), new Long(0x08208208, 0x82082082),\n new Long(0x40820820, 0x2c500), new Long(0x808c0146, 0x70820a38), new Long(0x9c30827c, 0xc37c20c2), new Long(0x20800867, 0x208208),\n new Long(0x02002080, 0xb1401020), new Long(0x00518000, 0x828e2023), new Long(0x209f1c20, 0x830a70c), new Long(0x853df0df, 0x51451450),\n new Long(0x14508214, 0x16142142), new Long(0x30805050, 0x60260264), new Long(0x43082098, 0x25050806), new Long(0x14564014, 0x42000083),\n new Long(0x20850051, 0x8500208), new Long(0x14140582, 0x80990c20), new Long(0x08261809, 0x82019202), new Long(0x90060941, 0x8920519),\n new Long(0xc22cb242, 0x22492492), new Long(0x0162492c, 0x43080505), new Long(0x86026026, 0x80414515), new Long(0xc5b43142, 0x37c38020),\n new Long(0x14508014, 0x42085085), new Long(0x50850051, 0x1414058), new Long(0x980990c2, 0x51456180), new Long(0x0c50a010, 0xe008316d),\n new Long(0x508b21f0, 0x2c52cb2c), new Long(0xc22cb249, 0x600d2c92), new Long(0x1850821c, 0x873c21c0), new Long(0x03cb1420, 0x2c01cb14),\n new Long(0x45185182, 0x20800821), new Long(0x08208000, 0x45002002), new Long(0x20871803, 0x8700614), new Long(0x050821cf, 0x740500f5),\n new Long(0x18609000, 0x934d9646), new Long(0x30824d30, 0x4c24d34d), new Long(0xc600d642, 0x1860821), new Long(0x25dac274, 0xc2a072c9),\n new Long(0x91c27472, 0x2c698398), new Long(0x89242242, 0x92420820), new Long(0x34b00900, 0x82087180), new Long(0xb09d0061, 0x1cb24976),\n new Long(0x9d1cb0a8, 0x60e62470), new Long(0x1574ce3e, 0xd31455d7), new Long(0x25c25d74, 0x1c600d38), new Long(0x423c3142, 0x51515454),\n new Long(0x1403c314, 0xc22c21cb), new Long(0x21431853, 0xb2c208), new Long(0x05145145, 0x34508b0), new Long(0x0c508718, 0x5515108f),\n new Long(0xf2051454, 0x8740500), new Long(0x0618f090, 0xe2534d92), new Long(0x6592c238, 0x49382659), new Long(0x21c600d6, 0x4423c314),\n new Long(0xcb2d1545, 0x72c2a042), new Long(0xa091c574, 0x422c3983), new Long(0x508b2c52, 0xb2c514), new Long(0x8034b08b, 0xf0c50871),\n new Long(0x45515108, 0xa810b2cb), new Long(0x715d1cb0, 0x2260e824), new Long(0x8e2d74ce, 0xe6592c53), new Long(0x38938238, 0x420c3081),\n new Long(0x22020cb1, 0x8508420), new Long(0xce0820ce, 0x70c25c20), new Long(0x08208b0d, 0x42082082), new Long(0x50821421, 0xc204208),\n new Long(0x832c5083, 0x21080880), new Long(0x0838c214, 0xa5083882), new Long(0xa9c39430, 0xaaaaaaaa), new Long(0x9fa9faaa, 0x1aaa7eaa),\n new Long(0x1420c308, 0x824820d0), new Long(0x84d94d64, 0x7184d371), new Long(0x1b7136d3, 0x34c24d07), new Long(0x1534d34d, 0x99093642),\n new Long(0x30c20530, 0x8340508), new Long(0x53592092, 0x34dc6136), new Long(0x4db4dc61, 0xa479c6dc), new Long(0x4924924a, 0x920a9f92),\n new Long(0x8192a82a, 0x72c22030), new Long(0x30930920, 0x724b24a), new Long(0x920e2422, 0xd72025c), new Long(0xc9082247, 0x92d70975),\n new Long(0x24e0892c, 0x880c2049), new Long(0xc2481cb0, 0x2c928c24), new Long(0x89088749, 0x80a52488), new Long(0xaac74394, 0x6a861b2a),\n new Long(0xab27b278, 0x81b2ca6), new Long(0x072c2203, 0xa3093092), new Long(0x6915ce5c, 0xd76985d3), new Long(0x771b6936, 0x5d74c25c),\n new Long(0x892d74d7, 0x724e0973), new Long(0x0880c205, 0x4c2481cb), new Long(0x739728c2, 0x6174da45), new Long(0xda4db5da, 0x4aa175c6),\n new Long(0x86486186, 0x6a869b27), new Long(0x308186ca, 0xcb14510), new Long(0x44205102, 0x220e2c51), new Long(0x38210e2c, 0xcb0d70c5),\n new Long(0x51421452, 0x14514208), new Long(0x4b085085, 0x51440c20), new Long(0x1440832c, 0xcb145108), new Long(0x488b0888, 0x94316208),\n new Long(0x9f7e79c3, 0xfaaa7dfa), new Long(0x7ea7df7d, 0x30819ea), new Long(0x20d01451, 0x65648558), new Long(0x93698399, 0x96135983),\n new Long(0x39071b71, 0xd9653645), new Long(0x96451534, 0x4e09909), new Long(0x051440c2, 0x21560834), new Long(0x60e65959, 0xd660e4da),\n new Long(0xc6dc6584, 0x9207e979), new Long(0xdf924820, 0xa82a8207), new Long(0x103081a6, 0x892072c5), new Long(0xb2ca30b2, 0x2c22072c),\n new Long(0x0538910e, 0x52c70d72), new Long(0x08e38914, 0x8b2cb2d7), new Long(0x204b24e0, 0x1cb1440c), new Long(0x8c2ca248, 0x874b2cb2),\n new Long(0x24488b08, 0x43948162), new Long(0x9b1f7e77, 0x9e786aa6), new Long(0xeca6a9e7, 0x51030819), new Long(0x2892072c, 0x8e38a30b),\n new Long(0x83936913, 0x69961759), new Long(0x4538771b, 0x74ce3976), new Long(0x08e38b2d, 0xc204e24e), new Long(0x81cb1440, 0x28c2ca24),\n new Long(0xda44e38e, 0x85d660e4), new Long(0x75c6da65, 0x698607e9), new Long(0x99e7864a, 0xa6ca6aa6)\n];\nconst offsetIncrs5 = /*3 bits per value */ [\n new Long(0x00080000, 0x30020000), new Long(0x20c060), new Long(0x04000000, 0x1000000), new Long(0x50603018, 0xdb6db6db),\n new Long(0x00002db6, 0xa4800002), new Long(0x41241240, 0x12492088), new Long(0x00104120, 0x40000100), new Long(0x92092052, 0x2492c420),\n new Long(0x096592d9, 0xc30d800), new Long(0xc36036d8, 0xb01b0c06), new Long(0x6c36db0d, 0x186c0003), new Long(0xb01b6c06, 0xad860361),\n new Long(0x5b6dd6dd, 0x360001b7), new Long(0x0db6030c, 0xc412311c), new Long(0xb6e36e06, 0xdb0d), new Long(0xdb01861b, 0x9188e06),\n new Long(0x71b72b62, 0x6dd6db), new Long(0x00800920, 0x40240249), new Long(0x904920c2, 0x20824900), new Long(0x40049000, 0x12012480),\n new Long(0xa4906120, 0x5524ad4a), new Long(0x02480015, 0x40924020), new Long(0x48409409, 0x92522512), new Long(0x24000820, 0x49201001),\n new Long(0x204a04a0, 0x29128924), new Long(0x00055549, 0x900830d2), new Long(0x24c24034, 0x934930c), new Long(0x02682493, 0x4186900),\n new Long(0x61201a48, 0x9a498612), new Long(0x355249d4, 0xc348001), new Long(0x940d2402, 0x24c40930), new Long(0x0924e24d, 0x1a40009a),\n new Long(0x06920106, 0x6204984a), new Long(0x92712692, 0x92494d54), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249),\n new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924),\n new Long(0x49249249, 0x92492492), new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492),\n new Long(0x24924924, 0x49249249), new Long(0x92492492, 0x24924924), new Long(0x49249249, 0x92492492), new Long(0x24924924)\n];\n// state map\n// 0 -> [(0, 0)]\n// 1 -> [(0, 2)]\n// 2 -> [(0, 1)]\n// 3 -> [(0, 1), (1, 1)]\n// 4 -> [(0, 2), (1, 2)]\n// 5 -> [t(0, 2), (0, 2), (1, 2), (2, 2)]\n// 6 -> [(0, 2), (2, 1)]\n// 7 -> [(0, 1), (2, 2)]\n// 8 -> [(0, 2), (2, 2)]\n// 9 -> [(0, 1), (1, 1), (2, 1)]\n// 10 -> [(0, 2), (1, 2), (2, 2)]\n// 11 -> [(0, 1), (2, 1)]\n// 12 -> [t(0, 1), (0, 1), (1, 1), (2, 1)]\n// 13 -> [(0, 2), (1, 2), (2, 2), (3, 2)]\n// 14 -> [t(0, 2), (0, 2), (1, 2), (2, 2), (3, 2)]\n// 15 -> [(0, 2), t(1, 2), (1, 2), (2, 2), (3, 2)]\n// 16 -> [(0, 2), (2, 1), (3, 1)]\n// 17 -> [(0, 1), t(1, 2), (2, 2), (3, 2)]\n// 18 -> [(0, 2), (3, 2)]\n// 19 -> [(0, 2), (1, 2), t(1, 2), (2, 2), (3, 2)]\n// 20 -> [t(0, 2), (0, 2), (1, 2), (3, 1)]\n// 21 -> [(0, 1), (1, 1), (3, 2)]\n// 22 -> [(0, 2), (2, 2), (3, 2)]\n// 23 -> [(0, 2), (1, 2), (3, 1)]\n// 24 -> [(0, 2), (1, 2), (3, 2)]\n// 25 -> [(0, 1), (2, 2), (3, 2)]\n// 26 -> [(0, 2), (3, 1)]\n// 27 -> [(0, 1), (3, 2)]\n// 28 -> [(0, 2), (2, 1), (4, 2)]\n// 29 -> [(0, 2), t(1, 2), (1, 2), (2, 2), (3, 2), (4, 2)]\n// 30 -> [(0, 2), (1, 2), (4, 2)]\n// 31 -> [(0, 2), (1, 2), (3, 2), (4, 2)]\n// 32 -> [(0, 2), (2, 2), (3, 2), (4, 2)]\n// 33 -> [(0, 2), (1, 2), t(2, 2), (2, 2), (3, 2), (4, 2)]\n// 34 -> [(0, 2), (1, 2), (2, 2), t(2, 2), (3, 2), (4, 2)]\n// 35 -> [(0, 2), (3, 2), (4, 2)]\n// 36 -> [(0, 2), t(2, 2), (2, 2), (3, 2), (4, 2)]\n// 37 -> [t(0, 2), (0, 2), (1, 2), (2, 2), (4, 2)]\n// 38 -> [(0, 2), (1, 2), (2, 2), (4, 2)]\n// 39 -> [t(0, 2), (0, 2), (1, 2), (2, 2), (3, 2), (4, 2)]\n// 40 -> [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2)]\n// 41 -> [(0, 2), (4, 2)]\n// 42 -> [t(0, 2), (0, 2), (1, 2), (2, 2), t(2, 2), (3, 2), (4, 2)]\n// 43 -> [(0, 2), (2, 2), (4, 2)]\n// 44 -> [(0, 2), (1, 2), t(1, 2), (2, 2), (3, 2), (4, 2)]\n/**\n * From org/apache/lucene/util/automaton/Lev2TParametricDescription.java\n * @hidden\n */\nclass lev2t_parametric_description_Lev2TParametricDescription extends ParametricDescription {\n constructor(w) {\n super(w, 2, [0, 2, 1, 0, 1, 0, -1, 0, 0, -1, 0, -1, -1, -1, -1, -1, -2, -1, -1, -1, -2, -1, -1, -2, -1, -1, -2, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2]);\n }\n transition(absState, position, vector) {\n // null absState should never be passed in\n // assert absState != -1;\n // decode absState -> state, offset\n let state = Math.floor(absState / (this._w + 1));\n let offset = absState % (this._w + 1);\n // assert offset >= 0;\n if (position === this._w) {\n if (state < 3) {\n const loc = vector * 3 + state;\n offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs0, loc, 1);\n state = ParametricDescription.unpack(lev2t_parametric_description_toStates0, loc, 2) - 1;\n }\n }\n else if (position === this._w - 1) {\n if (state < 5) {\n const loc = vector * 5 + state;\n offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs1, loc, 1);\n state = ParametricDescription.unpack(lev2t_parametric_description_toStates1, loc, 3) - 1;\n }\n }\n else if (position === this._w - 2) {\n if (state < 13) {\n const loc = vector * 13 + state;\n offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs2, loc, 2);\n state = ParametricDescription.unpack(lev2t_parametric_description_toStates2, loc, 4) - 1;\n }\n }\n else if (position === this._w - 3) {\n if (state < 28) {\n const loc = vector * 28 + state;\n offset += ParametricDescription.unpack(lev2t_parametric_description_offsetIncrs3, loc, 2);\n state = ParametricDescription.unpack(lev2t_parametric_description_toStates3, loc, 5) - 1;\n }\n }\n else if (position === this._w - 4) {\n if (state < 45) {\n const loc = vector * 45 + state;\n offset += ParametricDescription.unpack(offsetIncrs4, loc, 3);\n state = ParametricDescription.unpack(toStates4, loc, 6) - 1;\n }\n }\n else {\n if (state < 45) {\n const loc = vector * 45 + state;\n offset += ParametricDescription.unpack(offsetIncrs5, loc, 3);\n state = ParametricDescription.unpack(toStates5, loc, 6) - 1;\n }\n }\n if (state === -1) {\n // null state\n return -1;\n }\n else {\n // translate back to abs\n return state * (this._w + 1) + offset;\n }\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/fuzzy/levenshtein_automata.ts\n\n\n\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidden\n */\nclass levenshtein_automata_LevenshteinAutomata {\n constructor(input, editDistance) {\n this._word = input;\n this._editDistance = editDistance;\n this._alphabet = [...new Set(this._word)].sort((a, b) => a - b);\n this._numRanges = 0;\n this._rangeLower = new Array(this._alphabet.length + 2);\n this._rangeUpper = new Array(this._alphabet.length + 2);\n // calculate the unicode range intervals that exclude the alphabet\n // these are the ranges for all unicode characters not in the alphabet\n let lower = 0;\n for (let i = 0; i < this._alphabet.length; i++) {\n const higher = this._alphabet[i];\n if (higher > lower) {\n this._rangeLower[this._numRanges] = lower;\n this._rangeUpper[this._numRanges] = higher - 1;\n this._numRanges++;\n }\n lower = higher + 1;\n }\n /* add the final endpoint */\n if (lower <= MAX_CODE_POINT) {\n this._rangeLower[this._numRanges] = lower;\n this._rangeUpper[this._numRanges] = MAX_CODE_POINT;\n this._numRanges++;\n }\n if (editDistance === 1) {\n this._description = new lev1t_parametric_description_Lev1TParametricDescription(input.length);\n }\n else {\n this._description = new lev2t_parametric_description_Lev2TParametricDescription(input.length);\n }\n }\n /**\n * Transforms the NDFA to a DFA.\n * @returns {Automaton}\n */\n toAutomaton() {\n let automat = new Automaton();\n const range = 2 * this._editDistance + 1;\n // the number of states is based on the length of the word and the edit distance\n const numStates = this._description.size();\n // Prefix is not needed to be handled by the automaton.\n // stateOffset = 0;\n automat.createState();\n // create all states, and mark as accept states if appropriate\n for (let i = 1; i < numStates; i++) {\n let state = automat.createState();\n automat.setAccept(state, this._description.isAccept(i));\n }\n for (let k = 0; k < numStates; k++) {\n const xpos = this._description.getPosition(k);\n if (xpos < 0) {\n continue;\n }\n const end = xpos + Math.min(this._word.length - xpos, range);\n for (let x = 0; x < this._alphabet.length; x++) {\n const ch = this._alphabet[x];\n const cvec = this._getVector(ch, xpos, end);\n const dest = this._description.transition(k, xpos, cvec);\n if (dest >= 0) {\n automat.addTransition(k, dest, ch, ch);\n }\n }\n const dest = this._description.transition(k, xpos, 0);\n if (dest >= 0) {\n for (let r = 0; r < this._numRanges; r++) {\n automat.addTransition(k, dest, this._rangeLower[r], this._rangeUpper[r]);\n }\n }\n }\n // assert automat.deterministic;\n automat.finishState();\n return automat;\n }\n _getVector(x, pos, end) {\n let vector = 0;\n for (let i = pos; i < end; i++) {\n vector <<= 1;\n if (this._word[i] === x) {\n vector |= 1;\n }\n }\n return vector;\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/index_searcher.ts\n\n\n\n\n\nfunction calculateMinShouldMatch(optionalClauseCount, spec) {\n if (spec === undefined) {\n return 1;\n }\n if (typeof spec === \"number\") {\n return (spec < 0) ? optionalClauseCount + spec : spec;\n }\n let result = optionalClauseCount;\n if (spec.includes(\"<\")) {\n // Parse conditional minimumShouldMatch.;\n for (const s of spec.split(\" \")) {\n const parts = s.split(\"<\");\n const upperBound = parseInt(parts[0]);\n if (optionalClauseCount <= upperBound) {\n return result;\n }\n else {\n result = calculateMinShouldMatch(optionalClauseCount, parts[1]);\n }\n }\n return result;\n }\n if (spec.includes(\"%\")) {\n // Parse percentage.\n const percent = parseInt(spec.slice(0, -1));\n const calc = (result * percent) * (1 / 100);\n result = (calc < 0) ? result + Math.ceil(calc) : Math.floor(calc);\n }\n else {\n const calc = parseInt(spec);\n result = (calc < 0) ? result + calc : calc;\n }\n return (result < 1) ? 1 : result;\n}\n/**\n * @hidden\n */\nclass index_searcher_IndexSearcher {\n /**\n * Constructs an index searcher.\n * @param {Dict} invIdxs - the inverted indexes\n * @param {Set} docs - the ids of the documents\n */\n constructor(invIdxs, docs) {\n this._invIdxs = invIdxs;\n this._docs = docs;\n this._scorer = new Scorer(this._invIdxs);\n }\n search(query) {\n let queryResults = this._recursive(query.query, true);\n // Do final scoring.\n if (query.calculate_scoring !== undefined ? query.calculate_scoring : true) {\n return this._scorer.finalScore(query, queryResults);\n }\n const result = {};\n for (const key of queryResults.keys()) {\n result[key] = { score: 1 };\n }\n return result;\n }\n setDirty() {\n this._scorer.setDirty();\n }\n _recursive(query, doScoring) {\n let queryResults = new Map();\n const boost = query.boost !== undefined ? query.boost : 1;\n const fieldName = query.field !== undefined ? query.field : null;\n let root = null;\n let analyzer = null;\n if (this._invIdxs[fieldName] !== undefined) {\n root = this._invIdxs[fieldName].root;\n analyzer = this._invIdxs[fieldName].analyzer;\n }\n switch (query.type) {\n case \"bool\": {\n queryResults = null;\n if (query.must !== undefined) {\n queryResults = this._getUnique(query.must, doScoring, queryResults);\n }\n if (query.filter !== undefined) {\n queryResults = this._getUnique(query.filter, null, queryResults);\n }\n if (query.should !== undefined) {\n const shouldDocs = this._getAll(query.should, doScoring);\n let empty = false;\n if (queryResults === null) {\n empty = true;\n queryResults = new Map();\n }\n const msm = Math.max(1, calculateMinShouldMatch(query.should.length, query.minimum_should_match));\n if (empty && msm === 1) {\n // Take all documents.\n queryResults = shouldDocs;\n }\n else {\n // Remove documents with fewer matches.\n for (const [docId, res] of shouldDocs) {\n if (res.length >= msm) {\n if (queryResults.has(docId)) {\n queryResults.get(docId).push(...res);\n }\n else if (empty) {\n queryResults.set(docId, res);\n }\n else {\n queryResults.delete(docId);\n }\n }\n }\n }\n }\n // Match all documents if must/filter/should is not defined.\n if (queryResults === null) {\n queryResults = this._recursive({ type: \"match_all\" }, false);\n }\n if (query.not !== undefined) {\n let notDocs = this._getAll(query.not, null);\n // Remove all matching documents.\n for (const docId of notDocs.keys()) {\n if (queryResults.has(docId)) {\n queryResults.delete(docId);\n }\n }\n }\n // Boost query results afterwards.\n if (boost !== 1) {\n for (const [_, result] of queryResults) {\n for (let i = 0; i < result.length; i++) {\n result[i].boost *= boost;\n }\n }\n }\n break;\n }\n case \"term\": {\n const cps = toCodePoints(query.value);\n let termIdx = inverted_index_InvertedIndex.getTermIndex(cps, root);\n this._scorer.score(fieldName, boost, termIdx, doScoring, queryResults, cps);\n break;\n }\n case \"terms\": {\n for (let i = 0; i < query.value.length; i++) {\n const cps = toCodePoints(query.value[i]);\n let termIdx = inverted_index_InvertedIndex.getTermIndex(cps, root);\n this._scorer.score(fieldName, boost, termIdx, doScoring, queryResults, cps);\n }\n break;\n }\n case \"fuzzy\": {\n const [f, idf] = fuzzySearch(query, root);\n for (let i = 0; i < f.length; i++) {\n this._scorer.score(fieldName, boost * f[i].boost, f[i].index, doScoring, queryResults, f[i].term, idf);\n }\n break;\n }\n case \"wildcard\": {\n const enableScoring = query.enable_scoring !== undefined ? query.enable_scoring : false;\n const w = wildcardSearch(query, root);\n for (let i = 0; i < w.length; i++) {\n this._scorer.score(fieldName, boost, w[i].index, doScoring && enableScoring, queryResults, w[i].term);\n }\n break;\n }\n case \"match_all\": {\n for (let docId of this._docs) {\n this._scorer.scoreConstant(boost, docId, queryResults);\n }\n break;\n }\n case \"constant_score\": {\n let tmpQueryResults = this._getAll(query.filter, false);\n // Add to each document a constant score.\n for (const docId of tmpQueryResults.keys()) {\n this._scorer.scoreConstant(boost, docId, queryResults);\n }\n break;\n }\n case \"prefix\": {\n const enableScoring = query.enable_scoring !== undefined ? query.enable_scoring : false;\n const cps = toCodePoints(query.value);\n const termIdx = inverted_index_InvertedIndex.getTermIndex(cps, root);\n if (termIdx !== null) {\n const termIdxs = inverted_index_InvertedIndex.extendTermIndex(termIdx);\n for (let i = 0; i < termIdxs.length; i++) {\n this._scorer.score(fieldName, boost, termIdxs[i].index, doScoring && enableScoring, queryResults, [...cps, ...termIdxs[i].term]);\n }\n }\n break;\n }\n case \"exists\": {\n if (root !== null) {\n for (const docId of this._invIdxs[fieldName].docStore.keys()) {\n this._scorer.scoreConstant(boost, docId, queryResults);\n }\n }\n break;\n }\n case \"match\": {\n const terms = analyze(analyzer, query.value);\n const operator = query.operator !== undefined ? query.operator : \"or\";\n const boolQuery = { type: \"bool\" };\n const subQueries = [];\n if (operator === \"or\") {\n if (query.minimum_should_match !== undefined) {\n boolQuery.minimum_should_match = query.minimum_should_match;\n }\n // Create a should query.\n boolQuery.should = subQueries;\n }\n else {\n // Create a must query.\n boolQuery.must = subQueries;\n }\n boolQuery.boost = boost;\n if (query.fuzziness !== undefined) {\n let prefixLength = query.prefix_length !== undefined ? query.prefix_length : 2;\n let extended = query.extended !== undefined ? query.extended : false;\n // Add each fuzzy.\n for (let i = 0; i < terms.length; i++) {\n subQueries.push({\n type: \"fuzzy\", field: fieldName, value: terms[i], fuzziness: query.fuzziness,\n prefix_length: prefixLength, extended: extended\n });\n }\n }\n else {\n // Add each term.\n for (let i = 0; i < terms.length; i++) {\n subQueries.push({ type: \"term\", field: fieldName, value: terms[i] });\n }\n }\n queryResults = this._recursive(boolQuery, doScoring);\n break;\n }\n default:\n break;\n }\n return queryResults;\n }\n _getUnique(queries, doScoring, queryResults) {\n if (queries.length === 0) {\n return queryResults;\n }\n for (let i = 0; i < queries.length; i++) {\n let currDocs = this._recursive(queries[i], doScoring);\n if (queryResults === null) {\n queryResults = this._recursive(queries[0], doScoring);\n continue;\n }\n for (const docId of queryResults.keys()) {\n if (!currDocs.has(docId)) {\n queryResults.delete(docId);\n }\n else {\n queryResults.get(docId).push(...currDocs.get(docId));\n }\n }\n }\n return queryResults;\n }\n _getAll(queries, doScoring, queryResults = new Map()) {\n for (let i = 0; i < queries.length; i++) {\n let currDocs = this._recursive(queries[i], doScoring);\n for (const docId of currDocs.keys()) {\n if (!queryResults.has(docId)) {\n queryResults.set(docId, currDocs.get(docId));\n }\n else {\n queryResults.get(docId).push(...currDocs.get(docId));\n }\n }\n }\n return queryResults;\n }\n}\n/**\n * Calculates the levenshtein distance. Specialized version.\n * Copyright Kigiri: https://github.com/kigiri\n * Milot Mirdita: https://github.com/milot-mirdita\n * Toni Neubert: https://github.com/Viatorus/\n * @param {string} a - a string\n * @param {string} b - a string\n */\nfunction calculateLevenshteinDistance(a, b) {\n let i;\n let j;\n let prev;\n let val;\n const row = Array(a.length + 1);\n // init the row\n for (i = 0; i <= a.length; i++) {\n row[i] = i;\n }\n // fill in the rest\n for (i = 1; i <= b.length; i++) {\n prev = i;\n for (j = 1; j <= a.length; j++) {\n if (b[i - 1] === a[j - 1]) { // match\n val = row[j - 1];\n }\n else {\n val = Math.min(row[j - 1] + 1, // substitution\n Math.min(prev + 1, // insertion\n row[j] + 1)); // deletion\n // transposition\n if (i > 1 && j > 1 && b[i - 2] === a[j - 1] && a[j - 2] === b[i - 1]) {\n val = Math.min(val, row[j - 1] - (a[j - 1] === b[i - 1] ? 1 : 0));\n }\n }\n row[j - 1] = prev;\n prev = val;\n }\n row[a.length] = prev;\n }\n return row[a.length];\n}\n/**\n * Performs a fuzzy search.\n * @param {FuzzyQuery} query - the fuzzy query\n * @param {Index} root - the root index\n * @returns {[FuzzyResult, number]} - the fuzzy results and the maximum df\n */\nfunction fuzzySearch(query, root) {\n let value = toCodePoints(query.value);\n let fuzziness = query.fuzziness !== undefined ? query.fuzziness : \"AUTO\";\n if (fuzziness === \"AUTO\") {\n if (value.length <= 2) {\n fuzziness = 0;\n }\n else if (value.length <= 5) {\n fuzziness = 1;\n }\n else {\n fuzziness = 2;\n }\n }\n let prefixLength = query.prefix_length !== undefined ? query.prefix_length : 0;\n let extended = query.extended !== undefined ? query.extended : false;\n // Do just a prefix search if zero fuzziness.\n if (fuzziness === 0) {\n prefixLength = value.length;\n }\n let result = [];\n let startIdx = root;\n let prefix = value.slice(0, prefixLength);\n let fuzzy = value;\n let df = 0;\n // Perform a prefix search.\n if (prefixLength !== 0) {\n startIdx = inverted_index_InvertedIndex.getTermIndex(prefix, startIdx);\n fuzzy = fuzzy.slice(prefixLength);\n }\n // No startIdx found.\n if (startIdx === null) {\n return [result, df];\n }\n // Fuzzy is not necessary anymore, because prefix search includes the whole query value.\n if (fuzzy.length === 0) {\n if (extended) {\n // Add all terms down the index.\n const all = inverted_index_InvertedIndex.extendTermIndex(startIdx);\n for (let i = 0; i < all.length; i++) {\n result.push({ index: all[i].index, term: all[i].term, boost: 1 });\n df = Math.max(df, all[i].index.df);\n }\n }\n else if (startIdx.dc !== undefined) {\n // Add prefix search result.\n result.push({ index: startIdx, term: value, boost: 1 });\n df = startIdx.df;\n }\n return [result, df];\n }\n // The matching term.\n const term = [0];\n // Create an automaton from the fuzzy.\n const automaton = new RunAutomaton(new levenshtein_automata_LevenshteinAutomata(fuzzy, fuzziness).toAutomaton());\n function determineEditDistance(state, term, fuzzy) {\n // Check how many edits this fuzzy can still do.\n let ed = 0;\n state = automaton.step(state, 0);\n if (state !== -1 && automaton.isAccept(state)) {\n ed++;\n state = automaton.step(state, 0);\n if (state !== -1 && automaton.isAccept(state)) {\n ed++;\n }\n // Special handling for smaller terms.\n if (term.length < fuzzy.length) {\n if (ed !== fuzziness) {\n return calculateLevenshteinDistance(term, fuzzy);\n }\n // Include the term and fuzzy length.\n ed -= fuzzy.length - term.length;\n }\n }\n return fuzziness - ed;\n }\n function recursive(state, key, idx) {\n term[term.length - 1] = key;\n // Check the current key of term with the automaton.\n state = automaton.step(state, key);\n if (state === -1) {\n return;\n }\n if (automaton.isAccept(state)) {\n if (extended) {\n // Add all terms down the index.\n const all = inverted_index_InvertedIndex.extendTermIndex(idx);\n for (let i = 0; i < all.length; i++) {\n result.push({ index: all[i].index, term: all[i].term, boost: 1 });\n df = Math.max(df, all[i].index.df);\n }\n return;\n }\n else if (idx.df !== undefined) {\n // Calculate boost.\n const distance = determineEditDistance(state, term, fuzzy);\n const boost = Math.max(0, 1 - distance / Math.min(prefix.length + term.length, value.length));\n result.push({ index: idx, term: [...prefix, ...term], boost });\n df = Math.max(df, idx.df);\n }\n }\n term.push(0);\n for (const child of idx) {\n recursive(state, child[0], child[1]);\n }\n term.pop();\n }\n for (const child of startIdx) {\n recursive(0, child[0], child[1]);\n }\n return [result, df];\n}\n/**\n * Performs a wildcard search.\n * @param {WildcardQuery} query - the wildcard query\n * @param {Index} root - the root index\n * @returns {Array} - the results\n */\nfunction wildcardSearch(query, root) {\n let wildcard = toCodePoints(query.value);\n let result = [];\n function recursive(index, idx = 0, term = [], escaped = false) {\n if (index === null) {\n return;\n }\n if (idx === wildcard.length) {\n if (index.df !== undefined) {\n result.push({ index: index, term: term.slice() });\n }\n return;\n }\n // Escaped character.\n if (!escaped && wildcard[idx] === 92 /* \\ */) {\n recursive(index, idx + 1, term, true);\n }\n else if (!escaped && wildcard[idx] === 63 /* ? */) {\n for (const child of index) {\n recursive(child[1], idx + 1, [...term, child[0]]);\n }\n }\n else if (!escaped && wildcard[idx] === 42 /* * */) {\n // Check if asterisk is last wildcard character\n if (idx + 1 === wildcard.length) {\n const all = inverted_index_InvertedIndex.extendTermIndex(index);\n for (let i = 0; i < all.length; i++) {\n recursive(all[i].index, idx + 1, [...term, ...all[i].term]);\n }\n }\n else {\n // Iterate over the whole tree.\n recursive(index, idx + 1, term, false);\n const indices = [{ index: index, term: [] }];\n do {\n const index = indices.pop();\n for (const child of index.index) {\n recursive(child[1], idx + 1, [...term, ...index.term, child[0]]);\n indices.push({ index: child[1], term: [...index.term, child[0]] });\n }\n } while (indices.length !== 0);\n }\n }\n else {\n recursive(inverted_index_InvertedIndex.getTermIndex([wildcard[idx]], index), idx + 1, [...term, wildcard[idx]]);\n }\n }\n recursive(root);\n return result;\n}\n\n// EXTERNAL MODULE: ./packages/common/plugin.ts\nvar common_plugin = __webpack_require__(0);\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/full_text_search.ts\n\n\n\nclass full_text_search_FullTextSearch {\n /**\n * Initialize the full-text search for the given fields.\n * @param {object[]} fieldOptions - the field options\n * @param {string} fieldOptions.field - the name of the property field\n * @param {boolean=true} fieldOptions.store - flag to indicate if the full-text search should be stored on serialization or\n * rebuild on deserialization\n * @param {boolean=true} fieldOptions.optimizeChanges - flag to optimize updating and deleting of documents\n * (requires more memory but performs faster)\n * @param {Analyzer} fieldOptions.analyzer - an analyzer for the field\n * @param {string} [id] - the property name of the document index\n */\n constructor(fieldOptions = [], id) {\n this._invIdxs = {};\n // Create an inverted index for each field.\n for (let i = 0; i < fieldOptions.length; i++) {\n let fieldOption = fieldOptions[i];\n this._invIdxs[fieldOption.field] = new inverted_index_InvertedIndex(fieldOption);\n }\n this._id = id;\n this._docs = new Set();\n this._idxSearcher = new index_searcher_IndexSearcher(this._invIdxs, this._docs);\n }\n /**\n * Registers the full-text search as plugin.\n */\n static register() {\n common_plugin[\"a\" /* PLUGINS */][\"FullTextSearch\"] = full_text_search_FullTextSearch;\n }\n addDocument(doc, id = doc[this._id]) {\n let fieldNames = Object.keys(this._invIdxs);\n for (let i = 0, fieldName; i < fieldNames.length, fieldName = fieldNames[i]; i++) {\n let field = doc[fieldName];\n // Skip null and undefined.\n if (field === null || field === undefined) {\n continue;\n }\n if (typeof field !== \"string\") {\n // Convert number to string.\n if (typeof field === \"number\") {\n field = field.toString();\n }\n else {\n throw TypeError(\"Unsupported field type for full text search.\");\n }\n }\n this._invIdxs[fieldName].insert(field, id);\n }\n this._docs.add(id);\n this._idxSearcher.setDirty();\n }\n removeDocument(doc, id = doc[this._id]) {\n let fieldNames = Object.keys(this._invIdxs);\n for (let i = 0; i < fieldNames.length; i++) {\n this._invIdxs[fieldNames[i]].remove(id);\n }\n this._docs.delete(id);\n this._idxSearcher.setDirty();\n }\n updateDocument(doc, id = doc[this._id]) {\n this.removeDocument(doc, id);\n this.addDocument(doc, id);\n }\n clear() {\n for (let id of this._docs) {\n this.removeDocument(null, id);\n }\n }\n search(query) {\n return this._idxSearcher.search(query);\n }\n toJSON() {\n let serialized = { id: this._id, ii: {} };\n let fieldNames = Object.keys(this._invIdxs);\n for (let i = 0; i < fieldNames.length; i++) {\n const fieldName = fieldNames[i];\n serialized.ii[fieldName] = this._invIdxs[fieldName].toJSON();\n }\n return serialized;\n }\n static fromJSONObject(serialized, analyzers = {}) {\n let fts = new full_text_search_FullTextSearch([], serialized.id);\n let fieldNames = Object.keys(serialized.ii);\n for (let i = 0; i < fieldNames.length; i++) {\n const fieldName = fieldNames[i];\n fts._invIdxs[fieldName] = inverted_index_InvertedIndex.fromJSONObject(serialized.ii[fieldName], analyzers[fieldName]);\n }\n return fts;\n }\n}\n\n// CONCATENATED MODULE: ./packages/full-text-search/src/index.ts\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"FullTextSearch\", function() { return full_text_search_FullTextSearch; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"analyze\", function() { return analyze; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"StandardAnalyzer\", function() { return analyzer_StandardAnalyzer; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"whitespaceTokenizer\", function() { return whitespaceTokenizer; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"lowercaseTokenFilter\", function() { return lowercaseTokenFilter; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"uppercaseTokenFilter\", function() { return uppercaseTokenFilter; });\n\n\n\n\nfull_text_search_FullTextSearch[\"Analyzer\"] = {};\nfull_text_search_FullTextSearch[\"Analyzer\"][\"analyze\"] = analyze;\nfull_text_search_FullTextSearch[\"Analyzer\"][\"StandardAnalyzer\"] = analyzer_StandardAnalyzer;\nfull_text_search_FullTextSearch[\"Tokenizer\"] = {};\nfull_text_search_FullTextSearch[\"Tokenizer\"][\"whitespaceTokenizer\"] = whitespaceTokenizer;\nfull_text_search_FullTextSearch[\"TokenFilter\"] = {};\nfull_text_search_FullTextSearch[\"TokenFilter\"][\"lowercaseTokenFilter\"] = lowercaseTokenFilter;\nfull_text_search_FullTextSearch[\"TokenFilter\"][\"uppercaseTokenFilter\"] = uppercaseTokenFilter;\n\n/* harmony default export */ var src = __webpack_exports__[\"default\"] = (full_text_search_FullTextSearch);\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\nvar g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=lokidb.full-text-search.js.map"
},
{
"path": "dist/packages/full-text-search/types/common/plugin.d.ts",
"content": "/**\n * @hidden\n */\nexport declare const PLUGINS: void;\n"
},
{
"path": "dist/packages/full-text-search/types/common/types.d.ts",
"content": "/**\n * @hidden\n */\nimport { Loki } from \"../loki/src/loki\";\nexport interface StorageAdapter {\n loadDatabase(dbname: string): Promise;\n saveDatabase?(dbname: string, serialization: string): Promise;\n deleteDatabase?(dbname: string): Promise;\n mode?: string;\n exportDatabase?(dbname: string, dbref: Loki): Promise;\n}\nexport declare type Doc = T & {\n $loki: number;\n meta?: {\n created: number;\n revision: number;\n version: number;\n updated?: number;\n };\n};\nexport interface Dict {\n [index: string]: T;\n [index: number]: T;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/fs-storage/src/fs_storage.d.ts",
"content": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists using node fs module.\n */\nexport declare class FSStorage implements StorageAdapter {\n /**\n * Registers the fs storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the fs storage as plugin.\n */\n static deregister(): void;\n /**\n * Load data from file, will throw an error if the file does not exist\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise;\n /**\n * Save data to file, will throw an error if the file can't be saved\n * might want to expand this to avoid dataloss on partial save\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was persisted\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * Delete the database file, will throw an error if the\n * file can't be deleted\n * @param {string} dbname - the filename of the database to delete\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/fs-storage/src/index.d.ts",
"content": "import { FSStorage } from \"./fs_storage\";\nexport { FSStorage };\nexport default FSStorage;\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/analyzer.d.ts",
"content": "import { CharacterFilter } from \"./character_filter\";\nimport { Tokenizer, whitespaceTokenizer } from \"./tokenizer\";\nimport { lowercaseTokenFilter, TokenFilter } from \"./token_filter\";\n/**\n * A analyzer converts a string into tokens which are added to the inverted index for searching.\n */\nexport interface Analyzer {\n /**\n * The character filters of the analyzer.\n */\n char_filter?: CharacterFilter[];\n /**\n * The tokenizer of the analyzer.\n */\n tokenizer: Tokenizer;\n /**\n * The token filters of the analyzer.\n */\n token_filter?: TokenFilter[];\n}\n/**\n * Analyzes a given string.\n * @param {Analyzer} analyzer - the analyzer\n * @param {string} str - the string\n * @returns {string[]} - the tokens\n */\nexport declare function analyze(analyzer: Analyzer, str: string): string[];\n/**\n * An analyzer with the whitespace tokenizer and the lowercase token filter.\n */\nexport declare class StandardAnalyzer implements Analyzer {\n tokenizer: typeof whitespaceTokenizer;\n token_filter: (typeof lowercaseTokenFilter)[];\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/character_filter.d.ts",
"content": "/**\n * A character filter is used to preprocess a string before it is passed to a tokenizer.\n */\nexport declare type CharacterFilter = (value: string) => string;\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/token_filter.d.ts",
"content": "/**\n * A token filter takes tokens from a tokenizer and modify, delete or add tokens.\n */\nexport declare type TokenFilter = (value: string, index: number, array: string[]) => string;\n/**\n * Converts a token to lowercase.\n * @param {string} token - the token\n * @returns {string} - the lowercased token\n */\nexport declare function lowercaseTokenFilter(token: string): string;\n/**\n * Converts a token to uppercase.\n * @param {string} token - the token\n * @returns {string} - the uppercased token\n */\nexport declare function uppercaseTokenFilter(token: string): string;\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/tokenizer.d.ts",
"content": "/**\n * A tokenizer splits a string into individual tokens.\n */\nexport declare type Tokenizer = (value: string) => string[];\n/**\n * Splits a string at whitespace characters into tokens.\n * @param {string} value - the string\n * @returns {string[]} - the tokens\n */\nexport declare function whitespaceTokenizer(value: string): string[];\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/full_text_search.d.ts",
"content": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./query_types\";\nimport { Scorer } from \"./scorer\";\nimport { Analyzer } from \"./analyzer/analyzer\";\nexport declare class FullTextSearch {\n private _id;\n private _docs;\n private _idxSearcher;\n private _invIdxs;\n /**\n * Registers the full-text search as plugin.\n */\n static register(): void;\n /**\n * Initialize the full-text search for the given fields.\n * @param {object[]} fieldOptions - the field options\n * @param {string} fieldOptions.field - the name of the property field\n * @param {boolean=true} fieldOptions.store - flag to indicate if the full-text search should be stored on serialization or\n * rebuild on deserialization\n * @param {boolean=true} fieldOptions.optimizeChanges - flag to optimize updating and deleting of documents\n * (requires more memory but performs faster)\n * @param {Analyzer} fieldOptions.analyzer - an analyzer for the field\n * @param {string} [id] - the property name of the document index\n */\n constructor(fieldOptions?: FullTextSearch.FieldOptions[], id?: string);\n addDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;\n removeDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;\n updateDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;\n clear(): void;\n search(query: Query): Scorer.ScoreResults;\n toJSON(): FullTextSearch.Serialization;\n static fromJSONObject(serialized: FullTextSearch.Serialization, analyzers?: Dict): FullTextSearch;\n}\nexport declare namespace FullTextSearch {\n interface FieldOptions extends InvertedIndex.FieldOptions {\n field: string;\n }\n interface Serialization {\n id: string;\n ii: Dict;\n }\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/automaton.d.ts",
"content": "/**\n * Transition with dest, min and max.\n * @hidden\n */\nexport declare type Transition = [number, number, number];\n/**\n * @type {number}\n * @hidden\n */\nexport declare const MIN_CODE_POINT = 0;\n/**\n * @type {number}\n * @hidden\n */\nexport declare const MAX_CODE_POINT = 1114111;\n/**\n * From org/apache/lucene/util/automaton/Automaton.java\n * @hidden\n */\nexport declare class Automaton {\n private _stateTransitions;\n private _accept;\n private _nextState;\n private _currState;\n private _transitions;\n constructor();\n isAccept(n: number): boolean;\n createState(): number;\n setAccept(state: number, accept: boolean): void;\n finishState(): void;\n private _finishCurrentState();\n getStartPoints(): number[];\n step(state: number, label: number): number;\n getNumStates(): number;\n addTransition(source: number, dest: number, min: number, max: number): void;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts",
"content": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev1TParametricDescription.java\n * @hidden\n */\nexport declare class Lev1TParametricDescription extends ParametricDescription {\n constructor(w: number);\n transition(absState: number, position: number, vector: number): number;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts",
"content": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev2TParametricDescription.java\n * @hidden\n */\nexport declare class Lev2TParametricDescription extends ParametricDescription {\n constructor(w: number);\n transition(absState: number, position: number, vector: number): number;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts",
"content": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidden\n */\nexport declare class LevenshteinAutomata {\n private _word;\n private _numRanges;\n private _rangeLower;\n private _rangeUpper;\n private _description;\n private _alphabet;\n private _editDistance;\n constructor(input: number[], editDistance: number);\n /**\n * Transforms the NDFA to a DFA.\n * @returns {Automaton}\n */\n toAutomaton(): Automaton;\n private _getVector(x, pos, end);\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/long.d.ts",
"content": "/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nexport declare class Long {\n private _low;\n private _high;\n constructor(low?: number, high?: number);\n /**\n * Returns this long with bits arithmetically shifted to the right by the given amount.\n * @param {number} numBits - number of bits\n * @returns {Long} the long\n */\n shiftRight(numBits: number): Long;\n /**\n * Returns this long with bits arithmetically shifted to the left by the given amount.\n * @param {number} numBits - number of bits\n * @returns {Long} the long\n */\n shiftLeft(numBits: number): Long;\n /**\n * Returns the bitwise AND of this Long and the specified.\n * @param {Long} other - the other Long\n * @returns {Long} the long\n */\n and(other: Long): Long;\n /**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @returns {number}\n */\n toInt(): number;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/parametric_description.d.ts",
"content": "import { Long } from \"./long\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescription\n * @hidden\n */\nexport declare class ParametricDescription {\n protected _w: number;\n private _n;\n private _minErrors;\n constructor(w: number, n: number, minErrors: number[]);\n /**\n * Return the number of states needed to compute a Levenshtein DFA\n */\n size(): number;\n /**\n * Returns true if the state in any Levenshtein DFA is an accept state (final state).\n */\n isAccept(absState: number): boolean;\n /**\n * Returns the position in the input word for a given state.\n * This is the minimal boundary for the state.\n */\n getPosition(absState: number): number;\n static unpack(data: Long[], index: number, bitsPerValue: number): number;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/run_automaton.d.ts",
"content": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\nexport declare class RunAutomaton {\n private _points;\n private _accept;\n private _transitions;\n private _classmap;\n constructor(automaton: Automaton);\n getCharClass(c: number): number;\n step(state: number, c: number): number;\n isAccept(state: number): boolean;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/index.d.ts",
"content": "import { FullTextSearch } from \"./full_text_search\";\nimport { analyze, StandardAnalyzer } from \"./analyzer/analyzer\";\nimport { whitespaceTokenizer } from \"./analyzer/tokenizer\";\nimport { lowercaseTokenFilter, uppercaseTokenFilter } from \"./analyzer/token_filter\";\nexport { FullTextSearch, analyze, StandardAnalyzer, whitespaceTokenizer, lowercaseTokenFilter, uppercaseTokenFilter };\nexport default FullTextSearch;\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/index_searcher.d.ts",
"content": "import { Scorer } from \"./scorer\";\nimport { InvertedIndex } from \"./inverted_index\";\nimport { Query } from \"./query_types\";\nimport { Dict } from \"../../common/types\";\n/**\n * @hidden\n */\nexport declare class IndexSearcher {\n private _invIdxs;\n private _docs;\n private _scorer;\n /**\n * Constructs an index searcher.\n * @param {Dict} invIdxs - the inverted indexes\n * @param {Set} docs - the ids of the documents\n */\n constructor(invIdxs: Dict, docs: Set);\n search(query: Query): Scorer.ScoreResults;\n setDirty(): void;\n private _recursive(query, doScoring);\n private _getUnique(queries, doScoring, queryResults);\n private _getAll(queries, doScoring, queryResults?);\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/inverted_index.d.ts",
"content": "import { Analyzer } from \"./analyzer/analyzer\";\n/**\n * Converts a string into an array of code points.\n * @param str - the string\n * @returns {number[]} to code points\n * @hidden\n */\nexport declare function toCodePoints(str: string): number[];\n/**\n * Inverted index class handles featured text search for specific document fields.\n * @hidden\n */\nexport declare class InvertedIndex {\n analyzer: Analyzer;\n docCount: number;\n docStore: Map;\n totalFieldLength: number;\n root: InvertedIndex.Index;\n private _store;\n private _optimizeChanges;\n /**\n * @param {boolean} [options.store=true] - inverted index will be stored at serialization rather than rebuilt on load\n * @param {boolean} [options.optimizeChanges=true] - flag to store additional metadata inside the index for better\n * performance if an existing field is updated or removed\n * @param {Analyzer} [options.analyzer=] - the analyzer of this inverted index\n */\n constructor(options?: InvertedIndex.FieldOptions);\n /**\n * Adds defined fields of a document to the inverted index.\n * @param {string} field - the field to add\n * @param {number} docId - the doc id of the field\n */\n insert(field: string, docId: InvertedIndex.DocumentIndex): void;\n /**\n * Removes all relevant terms of a document from the inverted index.\n * @param {number} docId - the document.\n */\n remove(docId: InvertedIndex.DocumentIndex): void;\n /**\n * Gets the term index of a term.\n * @param {string} term - the term\n * @param {object} root - the term index to start from\n * @param {number} start - the position of the term string to start from\n * @return {object} - The term index or null if the term is not in the term tree.\n */\n static getTermIndex(term: number[], root: InvertedIndex.Index, start?: number): InvertedIndex.Index;\n /**\n * Extends a term index to all available term leafs.\n * @param {object} idx - the term index to start from\n * @param {number[]} [term=[]] - the current term\n * @param {Array} termIndices - all extended indices with their term\n * @returns {Array} - Array with term indices and extension\n */\n static extendTermIndex(idx: InvertedIndex.Index, term?: number[], termIndices?: InvertedIndex.IndexTerm[]): InvertedIndex.IndexTerm[];\n /**\n * Serialize the inverted index.\n * @returns {{docStore: *, _fields: *, index: *}}\n */\n toJSON(): InvertedIndex.Serialization;\n /**\n * Deserialize the inverted index.\n * @param {{docStore: *, _fields: *, index: *}} serialized - The serialized inverted index.\n * @param {Analyzer} analyzer[undefined] - an analyzer\n */\n static fromJSONObject(serialized: InvertedIndex.Serialization, analyzer?: Analyzer): InvertedIndex;\n private static _serializeIndex(idx);\n private static _deserializeIndex(serialized);\n /**\n * Set parent of to each index and regenerate the indexRef.\n * @param {Index} index - the index\n * @param {Index} parent - the parent\n */\n private _regenerate(index, parent);\n /**\n * Iterate over the whole inverted index and remove the document.\n * Delete branch if not needed anymore.\n * Function is needed if index is used without optimization.\n * @param {Index} idx - the index\n * @param {number} docId - the doc id\n * @returns {boolean} true if index is empty\n */\n private _remove(idx, docId);\n}\nexport declare namespace InvertedIndex {\n interface FieldOptions {\n store?: boolean;\n optimizeChanges?: boolean;\n analyzer?: Analyzer;\n }\n type Index = Map & {\n dc?: Map;\n df?: number;\n pa?: Index;\n };\n type IndexTerm = {\n index: Index;\n term: number[];\n };\n interface SerializedIndex {\n d?: {\n df: number;\n dc: [DocumentIndex, number][];\n };\n k?: number[];\n v?: SerializedIndex[];\n }\n type Serialization = SpareSerialization | FullSerialization;\n type SpareSerialization = {\n _store: false;\n _optimizeChanges: boolean;\n };\n type FullSerialization = {\n _store: true;\n _optimizeChanges: boolean;\n docCount: number;\n docStore: [DocumentIndex, DocStore][];\n totalFieldLength: number;\n root: SerializedIndex;\n };\n interface DocStore {\n fieldLength?: number;\n indexRef?: Index[];\n }\n type DocumentIndex = number | string;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/query_types.d.ts",
"content": "/**\n * Base query to enable boost to a query type.\n */\nexport interface BaseQuery {\n type: Type;\n boost?: number;\n}\n/**\n * A query which finds documents where a document field contains a term.\n */\nexport interface TermQuery extends BaseQuery<\"term\"> {\n field: string;\n value: string;\n}\n/**\n * A query which finds documents where a document field contains any of the terms.\n */\nexport interface TermsQuery extends BaseQuery<\"terms\"> {\n field: string;\n value: string[];\n}\n/**\n * A query which finds documents where the wildcard term can be applied at an existing document field term.\n */\nexport interface WildcardQuery extends BaseQuery<\"wildcard\"> {\n field: string;\n value: string;\n enable_scoring?: boolean;\n}\n/**\n * A query which finds documents where the fuzzy term can be transformed into an existing document field term within a\n * given edit distance.\n */\nexport interface FuzzyQuery extends BaseQuery<\"fuzzy\"> {\n field: string;\n value: string;\n fuzziness?: 0 | 1 | 2 | \"AUTO\";\n prefix_length?: number;\n extended?: boolean;\n}\n/**\n * A query which matches documents containing the prefix of a term inside a field.\n */\nexport interface PrefixQuery extends BaseQuery<\"prefix\"> {\n field: string;\n value: string;\n enable_scoring?: boolean;\n}\n/**\n * A query which matches all documents with a given field.\n */\nexport interface ExistsQuery extends BaseQuery<\"exists\"> {\n field: string;\n}\n/**\n * A query which tokenizes the given text into tokens and performs a sub query for each token. The results are combined\n * using a boolean operator.\n */\nexport interface MatchQuery extends BaseQuery<\"match\"> {\n field: string;\n value: string;\n minimum_should_match?: number | string;\n operator?: \"and\" | \"or\";\n fuzziness?: 0 | 1 | 2 | \"AUTO\";\n prefix_length?: number;\n extended?: boolean;\n}\n/**\n * A query that matches all documents and giving them a constant score equal to the query boost.\n*/\nexport interface MatchQueryAll extends BaseQuery<\"match_all\"> {\n}\n/**\n * A query that wraps sub queries and returns a constant score equal to the query boost for every document in the filter.\n */\nexport interface ConstantScoreQuery extends BaseQuery<\"constant_score\"> {\n filter: QueryTypes[];\n}\n/**\n * A query that matches documents matching boolean combinations of sub queries.\n */\nexport interface BoolQuery extends BaseQuery<\"bool\"> {\n must?: QueryTypes[];\n filter?: QueryTypes[];\n should?: QueryTypes[];\n not?: QueryTypes[];\n minimum_should_match?: number | string;\n}\n/**\n * Union type of possible query types.\n */\nexport declare type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuery | WildcardQuery | FuzzyQuery | MatchQuery | MatchQueryAll | PrefixQuery | ExistsQuery;\n/**\n * The main query with the actually full-text search query and the scoring parameters.\n */\nexport interface Query {\n query: QueryTypes;\n calculate_scoring?: boolean;\n explain?: boolean;\n bm25?: {\n k1: number;\n b: number;\n };\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/scorer.d.ts",
"content": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./query_types\";\n/**\n * @hidden\n */\nexport declare class Scorer {\n private _invIdxs;\n private _cache;\n constructor(invIdxs: Dict);\n setDirty(): void;\n score(fieldName: string, boost: number, termIdx: InvertedIndex.Index, doScoring: boolean | null, queryResults: Scorer.QueryResults, term: number[], df?: number): void;\n scoreConstant(boost: number, docId: InvertedIndex.DocumentIndex, queryResults: Scorer.QueryResults): Scorer.QueryResults;\n finalScore(query: Query, queryResults: Scorer.QueryResults): Scorer.ScoreResults;\n private static _calculateFieldLength(fieldLength);\n private _getCache(fieldName);\n /**\n * Returns the idf by either calculate it or use a cached one.\n * @param {string} fieldName - the name of the field\n * @param {number} docFreq - the doc frequency of the term\n * @returns {number} the idf\n * @private\n */\n private _idf(fieldName, docFreq);\n private _avgFieldLength(fieldName);\n}\nexport declare namespace Scorer {\n interface IDFCache {\n idfs: Dict;\n avgFieldLength: number;\n }\n interface QueryResult {\n tf?: number;\n idf?: number;\n boost: number;\n fieldName?: string;\n term?: number[];\n }\n type QueryResults = Map;\n interface BM25Explanation {\n boost: number;\n score: number;\n docID: number;\n fieldName: string;\n index: string;\n idf: number;\n tfNorm: number;\n tf: number;\n fieldLength: number;\n avgFieldLength: number;\n }\n interface ConstantExplanation {\n boost: number;\n score: number;\n }\n type ScoreExplanation = BM25Explanation | ConstantExplanation;\n type ScoreResult = {\n score: number;\n explanation?: ScoreExplanation[];\n };\n type ScoreResults = Dict;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language/src/index.d.ts",
"content": "export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from \"./language\";\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language/src/language.d.ts",
"content": "export declare function generateTrimmer(wordCharacters: string): (token: string) => string;\nexport declare function generateStopWordFilter(stopWords: string[]): (token: string) => string;\nexport declare class Among {\n s_size: number;\n s: number[];\n substring_i: number;\n result: number;\n method: any;\n constructor(s: string, substring_i: number, result: number, method?: any);\n}\nexport declare class SnowballProgram {\n current: string;\n bra: number;\n ket: number;\n limit: number;\n cursor: number;\n limit_backward: number;\n constructor();\n setCurrent(word: string): void;\n getCurrent(): string;\n in_grouping(s: number[], min: number, max: number): boolean;\n in_grouping_b(s: number[], min: number, max: number): boolean;\n out_grouping(s: number[], min: number, max: number): boolean;\n out_grouping_b(s: number[], min: number, max: number): boolean;\n eq_s(s_size: number, s: string): boolean;\n eq_s_b(s_size: number, s: string): boolean;\n find_among(v: Among[], v_size: number): number;\n find_among_b(v: Among[], v_size: number): number;\n replace_s(c_bra: number, c_ket: number, s: string): number;\n slice_check(): void;\n slice_from(s: string): void;\n slice_del(): void;\n insert(c_bra: number, c_ket: number, s: string): void;\n slice_to(): string;\n eq_v_b(s: string): boolean;\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-de/src/german_analyzer.d.ts",
"content": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class GermanAnalyzer implements Analyzer {\n tokenizer: (str: string) => string[];\n token_filter: ((token: string) => string)[];\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-de/src/index.d.ts",
"content": "import { GermanAnalyzer } from \"./german_analyzer\";\nexport { GermanAnalyzer };\nexport default GermanAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-en/src/english_analyzer.d.ts",
"content": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class EnglishAnalyzer implements Analyzer {\n tokenizer: (str: string) => string[];\n token_filter: ((token: string) => string)[];\n}\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-en/src/index.d.ts",
"content": "import { EnglishAnalyzer } from \"./english_analyzer\";\nexport { EnglishAnalyzer };\nexport default EnglishAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search/types/indexed-storage/src/index.d.ts",
"content": "import { IndexedStorage } from \"./indexed_storage\";\nexport { IndexedStorage };\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/full-text-search/types/indexed-storage/src/indexed_storage.d.ts",
"content": "import { StorageAdapter } from \"../../common/types\";\n/**\n * Loki persistence adapter class for indexedDb.\n * This class fulfills abstract adapter interface which can be applied to other storage methods.\n * Utilizes the included LokiCatalog app/key/value database for actual database persistence.\n * IndexedDb storage is provided per-domain, so we implement app/key/value database to\n * allow separate contexts for separate apps within a domain.\n */\nexport declare class IndexedStorage implements StorageAdapter {\n private _appname;\n private catalog;\n /**\n * Registers the indexed storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the indexed storage as plugin.\n */\n static deregister(): void;\n /**\n * @param {string} [appname=loki] - Application name context can be used to distinguish subdomains, \"loki\" by default\n */\n constructor(appname?: string);\n /**\n * Retrieves a serialized db string from the catalog.\n *\n * @example\n * // LOAD\n * var idbAdapter = new LokiIndexedAdapter(\"finance\");\n * var db = new loki(\"test\", { adapter: idbAdapter });\n * db.base(function(result) {\n * console.log(\"done\");\n * });\n *\n * @param {string} dbname - the name of the database to retrieve.\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise<{}>;\n /**\n * Saves a serialized db to the catalog.\n *\n * @example\n * // SAVE : will save App/Key/Val as \"finance\"/\"test\"/{serializedDb}\n * let idbAdapter = new LokiIndexedAdapter(\"finance\");\n * let db = new loki(\"test\", { adapter: idbAdapter });\n * let coll = db.addCollection(\"testColl\");\n * coll.insert({test: \"val\"});\n * db.saveDatabase(); // could pass callback if needed for async complete\n *\n * @param {string} dbname - the name to give the serialized database within the catalog.\n * @param {string} dbstring - the serialized db string to save.\n * @returns {Promise} a Promise that resolves after the database was persisted\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * Deletes a serialized db from the catalog.\n *\n * @example\n * // DELETE DATABASE\n * // delete \"finance\"/\"test\" value from catalog\n * idbAdapter.deleteDatabase(\"test\", function {\n * // database deleted\n * });\n *\n * @param {string} dbname - the name of the database to delete from the catalog.\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n /**\n * Removes all database partitions and pages with the base filename passed in.\n * This utility method does not (yet) guarantee async deletions will be completed before returning\n *\n * @param {string} dbname - the base filename which container, partitions, or pages are derived\n */\n deleteDatabasePartitions(dbname: string): void;\n /**\n * Retrieves object array of catalog entries for current app.\n *\n * @example\n * idbAdapter.getDatabaseList(function(result) {\n * // result is array of string names for that appcontext (\"finance\")\n * result.forEach(function(str) {\n * console.log(str);\n * });\n * });\n *\n * @param {function} callback - should accept array of database names in the catalog for current app.\n */\n getDatabaseList(callback: (names: string[]) => void): void;\n /**\n * Allows retrieval of list of all keys in catalog along with size\n * @param {function} callback - (Optional) callback to accept result array.\n */\n getCatalogSummary(callback: (entry: Entry[]) => void): void;\n}\nexport interface Entry {\n app: string;\n key: string;\n size: number;\n}\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/full-text-search/types/local-storage/src/index.d.ts",
"content": "import { LocalStorage } from \"./local_storage\";\nexport { LocalStorage };\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/full-text-search/types/local-storage/src/local_storage.d.ts",
"content": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists to web browser's local storage object\n * @constructor LocalStorageAdapter\n */\nexport declare class LocalStorage implements StorageAdapter {\n /**\n * Registers the local storage as plugin.\n */\n static register(): void;\n /**\n * Deregisters the local storage as plugin.\n */\n static deregister(): void;\n /**\n * loadDatabase() - Load data from localstorage\n * @param {string} dbname - the name of the database to load\n * @returns {Promise} a Promise that resolves after the database was loaded\n */\n loadDatabase(dbname: string): Promise;\n /**\n * saveDatabase() - save data to localstorage, will throw an error if the file can't be saved\n * might want to expand this to avoid dataloss on partial save\n * @param {string} dbname - the filename of the database to load\n * @returns {Promise} a Promise that resolves after the database was saved\n */\n saveDatabase(dbname: string, dbstring: string): Promise;\n /**\n * deleteDatabase() - delete the database from localstorage, will throw an error if it\n * can't be deleted\n * @param {string} dbname - the filename of the database to delete\n * @returns {Promise} a Promise that resolves after the database was deleted\n */\n deleteDatabase(dbname: string): Promise;\n}\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/full-text-search/types/loki/src/avl_index.d.ts",
"content": "import { IRangedIndex, IRangedIndexRequest } from \"./ranged_indexes\";\nimport { ILokiComparer } from \"./comparators\";\n/**\n * Treenode type for binary search tree (BST) implementation.\n *\n * To support duplicates, we may need to either repurpose parent to\n * point to 'elder' sibling or add a siblingId to point to owner of\n * node represented in tree.\n */\nexport declare type TreeNode = {\n id: number;\n value: T;\n parent: number | null;\n balance: number;\n height: number;\n left: number | null;\n right: number | null;\n siblings: number[];\n};\nexport interface ITreeNodeHash {\n [id: number]: TreeNode;\n}\n/**\n * LokiDB AVL Balanced Binary Tree Index implementation.\n * To support duplicates, we use siblings (array) in tree nodes.\n * Basic AVL components guided by William Fiset tutorials at :\n * https://github.com/williamfiset/data-structures/blob/master/com/williamfiset/datastructures/balancedtree/AVLTreeRecursive.java\n * https://www.youtube.com/watch?v=g4y2h70D6Nk&list=PLDV1Zeh2NRsD06x59fxczdWLhDDszUHKt\n */\nexport declare class AvlTreeIndex implements IRangedIndex {\n name: string;\n comparator: ILokiComparer;\n nodes: ITreeNodeHash;\n apex: number | null;\n /**\n * Initializes index with property name and a comparer function.\n */\n constructor(name: string, comparator: ILokiComparer);\n backup(): AvlTreeIndex;\n restore(tree: AvlTreeIndex