Showing preview only (3,022K chars total). Download the full file or copy to clipboard to get everything.
Repository: LokiJS-Forge/LokiDB
Branch: master
Commit: ccc45527b2e9
Files: 643
Total size: 2.7 MB
Directory structure:
gitextract_bumayf7k/
├── .editorconfig
├── .github/
│ ├── ISSUE_TEMPLATE.md
│ └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── DEVELOPER.md
├── LICENSE
├── README.md
├── benchmark/
│ ├── benchmark.js
│ └── benchmark_indexes.js
├── config/
│ ├── jasmine.json
│ ├── karma.config.js
│ ├── nycrc.json
│ ├── nycrc.node.json
│ ├── tsconfig.tslint.json
│ ├── tsconfig.webpack.json
│ ├── tslint.json
│ └── webpack-config-creator.js
├── dist/
│ └── packages/
│ ├── fs-storage/
│ │ ├── lokidb.fs-storage.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── full-text-search/
│ │ ├── lokidb.full-text-search.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── full-text-search-language/
│ │ ├── lokidb.full-text-search-language.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── full-text-search-language-de/
│ │ ├── lokidb.full-text-search-language-de.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── full-text-search-language-en/
│ │ ├── lokidb.full-text-search-language-en.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── indexed-storage/
│ │ ├── lokidb.indexed-storage.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── local-storage/
│ │ ├── lokidb.local-storage.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── loki/
│ │ ├── lokidb.loki.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ ├── memory-storage/
│ │ ├── lokidb.memory-storage.js
│ │ └── types/
│ │ ├── common/
│ │ │ ├── plugin.d.ts
│ │ │ └── types.d.ts
│ │ ├── fs-storage/
│ │ │ └── src/
│ │ │ ├── fs_storage.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search/
│ │ │ └── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.d.ts
│ │ │ │ ├── character_filter.d.ts
│ │ │ │ ├── token_filter.d.ts
│ │ │ │ └── tokenizer.d.ts
│ │ │ ├── full_text_search.d.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.d.ts
│ │ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ │ ├── levenshtein_automata.d.ts
│ │ │ │ ├── long.d.ts
│ │ │ │ ├── parametric_description.d.ts
│ │ │ │ └── run_automaton.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── index_searcher.d.ts
│ │ │ ├── inverted_index.d.ts
│ │ │ ├── query_types.d.ts
│ │ │ └── scorer.d.ts
│ │ ├── full-text-search-language/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── language.d.ts
│ │ ├── full-text-search-language-de/
│ │ │ └── src/
│ │ │ ├── german_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── full-text-search-language-en/
│ │ │ └── src/
│ │ │ ├── english_analyzer.d.ts
│ │ │ └── index.d.ts
│ │ ├── indexed-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── indexed_storage.d.ts
│ │ ├── local-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── local_storage.d.ts
│ │ ├── loki/
│ │ │ └── src/
│ │ │ ├── avl_index.d.ts
│ │ │ ├── clone.d.ts
│ │ │ ├── collection.d.ts
│ │ │ ├── comparators.d.ts
│ │ │ ├── dynamic_view.d.ts
│ │ │ ├── event_emitter.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── loki.d.ts
│ │ │ ├── operator_packages.d.ts
│ │ │ ├── ranged_indexes.d.ts
│ │ │ ├── result_set.d.ts
│ │ │ └── unique_index.d.ts
│ │ ├── memory-storage/
│ │ │ └── src/
│ │ │ ├── index.d.ts
│ │ │ └── memory_storage.d.ts
│ │ └── partitioning-adapter/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── partitioning_adapter.d.ts
│ └── partitioning-adapter/
│ ├── lokidb.partitioning-adapter.js
│ └── types/
│ ├── common/
│ │ ├── plugin.d.ts
│ │ └── types.d.ts
│ ├── fs-storage/
│ │ └── src/
│ │ ├── fs_storage.d.ts
│ │ └── index.d.ts
│ ├── full-text-search/
│ │ └── src/
│ │ ├── analyzer/
│ │ │ ├── analyzer.d.ts
│ │ │ ├── character_filter.d.ts
│ │ │ ├── token_filter.d.ts
│ │ │ └── tokenizer.d.ts
│ │ ├── full_text_search.d.ts
│ │ ├── fuzzy/
│ │ │ ├── automaton.d.ts
│ │ │ ├── lev1t_parametric_description.d.ts
│ │ │ ├── lev2t_parametric_description.d.ts
│ │ │ ├── levenshtein_automata.d.ts
│ │ │ ├── long.d.ts
│ │ │ ├── parametric_description.d.ts
│ │ │ └── run_automaton.d.ts
│ │ ├── index.d.ts
│ │ ├── index_searcher.d.ts
│ │ ├── inverted_index.d.ts
│ │ ├── query_types.d.ts
│ │ └── scorer.d.ts
│ ├── full-text-search-language/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── language.d.ts
│ ├── full-text-search-language-de/
│ │ └── src/
│ │ ├── german_analyzer.d.ts
│ │ └── index.d.ts
│ ├── full-text-search-language-en/
│ │ └── src/
│ │ ├── english_analyzer.d.ts
│ │ └── index.d.ts
│ ├── indexed-storage/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── indexed_storage.d.ts
│ ├── local-storage/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── local_storage.d.ts
│ ├── loki/
│ │ └── src/
│ │ ├── avl_index.d.ts
│ │ ├── clone.d.ts
│ │ ├── collection.d.ts
│ │ ├── comparators.d.ts
│ │ ├── dynamic_view.d.ts
│ │ ├── event_emitter.d.ts
│ │ ├── index.d.ts
│ │ ├── loki.d.ts
│ │ ├── operator_packages.d.ts
│ │ ├── ranged_indexes.d.ts
│ │ ├── result_set.d.ts
│ │ └── unique_index.d.ts
│ ├── memory-storage/
│ │ └── src/
│ │ ├── index.d.ts
│ │ └── memory_storage.d.ts
│ └── partitioning-adapter/
│ └── src/
│ ├── index.d.ts
│ └── partitioning_adapter.d.ts
├── docs/
│ ├── comparators.md
│ ├── css/
│ │ ├── codemirror/
│ │ │ ├── codemirror.css
│ │ │ └── foldgutter.css
│ │ └── javascript_editor.css
│ ├── index.md
│ ├── js/
│ │ ├── codemirror/
│ │ │ ├── addon/
│ │ │ │ ├── edit/
│ │ │ │ │ └── matchbrackets.js
│ │ │ │ └── fold/
│ │ │ │ ├── brace-fold.js
│ │ │ │ ├── foldcode.js
│ │ │ │ └── foldgutter.js
│ │ │ ├── lib/
│ │ │ │ └── codemirror.js
│ │ │ └── mode/
│ │ │ └── javascript/
│ │ │ └── javascript.js
│ │ ├── gitter.js
│ │ └── javascript_editor.js
│ ├── operator_packages.md
│ └── ranged_indexes.md
├── integration/
│ ├── .gitignore
│ ├── config/
│ │ ├── jasmine.json
│ │ ├── karma.amd.config.js
│ │ └── karma.browser.config.js
│ ├── package.json
│ ├── scripts/
│ │ └── install_lokidb.ts
│ └── spec/
│ ├── generic/
│ │ ├── full-text-search-language-de.spec.js
│ │ ├── full-text-search-language-en.spec.js
│ │ ├── full-text-search-language.spec.js
│ │ ├── full-text-search.spec.js
│ │ ├── loki.spec.js
│ │ ├── memory-storage.spec.js
│ │ └── partitioning-adapter.spec.js
│ ├── helper/
│ │ └── integration.helper.js
│ ├── node/
│ │ └── node-storage.spec.js
│ └── web/
│ ├── indexed-storage.spec.js
│ └── local-storage.spec.js
├── mkdocs.yml
├── package.json
├── packages/
│ ├── common/
│ │ ├── plugin.ts
│ │ └── types.ts
│ ├── fs-storage/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── node/
│ │ │ └── fs_storage.spec.ts
│ │ ├── src/
│ │ │ ├── fs_storage.ts
│ │ │ └── index.ts
│ │ └── webpack.config.js
│ ├── full-text-search/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ ├── generic/
│ │ │ │ ├── analyzer/
│ │ │ │ │ ├── character_filter.spec.ts
│ │ │ │ │ ├── token_filter.spec.ts
│ │ │ │ │ └── tokenizer.spec.ts
│ │ │ │ ├── full_text_search.spec.ts
│ │ │ │ ├── inverted_index.spec.ts
│ │ │ │ └── search/
│ │ │ │ ├── fuzzy.spec.ts
│ │ │ │ └── wildcard.spec.ts
│ │ │ └── node/
│ │ │ ├── MOCK_DATA.ts
│ │ │ ├── QUERIES.ts
│ │ │ └── elasticsearch.spec.ts
│ │ ├── src/
│ │ │ ├── analyzer/
│ │ │ │ ├── analyzer.ts
│ │ │ │ ├── character_filter.ts
│ │ │ │ ├── token_filter.ts
│ │ │ │ └── tokenizer.ts
│ │ │ ├── full_text_search.ts
│ │ │ ├── fuzzy/
│ │ │ │ ├── automaton.ts
│ │ │ │ ├── lev1t_parametric_description.ts
│ │ │ │ ├── lev2t_parametric_description.ts
│ │ │ │ ├── levenshtein_automata.ts
│ │ │ │ ├── long.ts
│ │ │ │ ├── parametric_description.ts
│ │ │ │ └── run_automaton.ts
│ │ │ ├── index.ts
│ │ │ ├── index_searcher.ts
│ │ │ ├── inverted_index.ts
│ │ │ ├── query_types.ts
│ │ │ └── scorer.ts
│ │ └── webpack.config.js
│ ├── full-text-search-language/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── helper/
│ │ │ └── create_lanuage_test.helper.ts
│ │ ├── src/
│ │ │ ├── index.ts
│ │ │ └── language.ts
│ │ └── webpack.config.js
│ ├── full-text-search-language-de/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── generic/
│ │ │ └── german_analyzer.spec.ts
│ │ ├── src/
│ │ │ ├── german_analyzer.ts
│ │ │ └── index.ts
│ │ └── webpack.config.js
│ ├── full-text-search-language-en/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── generic/
│ │ │ └── english_analyzer.spec.ts
│ │ ├── src/
│ │ │ ├── english_analyzer.ts
│ │ │ └── index.ts
│ │ └── webpack.config.js
│ ├── indexed-storage/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── web/
│ │ │ └── indexed_storage.spec.ts
│ │ ├── src/
│ │ │ ├── index.ts
│ │ │ └── indexed_storage.ts
│ │ └── webpack.config.js
│ ├── local-storage/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── web/
│ │ │ └── local_storage.spec.ts
│ │ ├── src/
│ │ │ ├── index.ts
│ │ │ └── local_storage.ts
│ │ └── webpack.config.js
│ ├── loki/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── generic/
│ │ │ ├── avl-index.spec.ts
│ │ │ ├── changesApi.spec.ts
│ │ │ ├── cloning.spec.ts
│ │ │ ├── collection.spec.ts
│ │ │ ├── comparators.spec.ts
│ │ │ ├── dynamic_view.spec.ts
│ │ │ ├── eventEmitter.spec.ts
│ │ │ ├── joins.spec.ts
│ │ │ ├── operator_packages.spec.ts
│ │ │ ├── ops.spec.ts
│ │ │ ├── persistence.spec.ts
│ │ │ ├── remove.spec.ts
│ │ │ ├── sortingIndexing.spec.ts
│ │ │ ├── stage.spec.ts
│ │ │ ├── stats.spec.ts
│ │ │ ├── test.spec.ts
│ │ │ ├── transforms.spec.ts
│ │ │ ├── typed.spec.ts
│ │ │ └── unique.spec.ts
│ │ ├── src/
│ │ │ ├── avl_index.ts
│ │ │ ├── clone.ts
│ │ │ ├── collection.ts
│ │ │ ├── comparators.ts
│ │ │ ├── dynamic_view.ts
│ │ │ ├── event_emitter.ts
│ │ │ ├── index.ts
│ │ │ ├── loki.ts
│ │ │ ├── operator_packages.ts
│ │ │ ├── ranged_indexes.ts
│ │ │ ├── result_set.ts
│ │ │ └── unique_index.ts
│ │ └── webpack.config.js
│ ├── memory-storage/
│ │ ├── package.json
│ │ ├── spec/
│ │ │ └── generic/
│ │ │ └── memory_storage.spec.ts
│ │ ├── src/
│ │ │ ├── index.ts
│ │ │ └── memory_storage.ts
│ │ └── webpack.config.js
│ └── partitioning-adapter/
│ ├── package.json
│ ├── spec/
│ │ └── generic/
│ │ └── partitioning.spec.ts
│ ├── src/
│ │ ├── index.ts
│ │ └── partitioning_adapter.ts
│ └── webpack.config.js
├── scripts/
│ ├── build.ts
│ ├── common.ts
│ └── deploy.ts
└── tsconfig.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
root = true
[*]
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
charset = utf-8
indent_style = space
indent_size = 2
================================================
FILE: .github/ISSUE_TEMPLATE.md
================================================
<!--
PLEASE HELP US PROCESS GITHUB ISSUES FASTER BY PROVIDING THE FOLLOWING INFORMATION.
ISSUES MISSING IMPORTANT INFORMATION MAY BE CLOSED WITHOUT INVESTIGATION.
-->
## I'm submitting a...
<!-- Check one of the following options with "x" -->
<pre><code>
[ ] Regression (a behavior that used to work and stopped working in a new release)
[ ] Bug report <!-- Please search GitHub for a similar issue or PR before submitting -->
[ ] Feature request
[ ] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead see https://github.com/LokiJS-Forge/LokiDB/blob/master/CONTRIBUTING.md#question
</code></pre>
## Current behavior
<!-- Describe how the issue manifests. -->
## Expected behavior
<!-- Describe what the desired behavior would be. -->
## Minimal reproduction of the problem with instructions
<!--
For bug reports please provide the *STEPS TO REPRODUCE* and if possible a *MINIMAL DEMO* of the problem via https://plnkr.co or similar.
-->
## What is the motivation / use case for changing the behavior?
<!-- Describe the motivation or the concrete use case. -->
## Environment
<pre><code>
LokiDB version: X.Y.Z
<!-- Check whether this is still an issue in the most recent LokiDB version -->
Browser/Node version: Browser X.Y.Z.
Others:
<!-- Anything else relevant? Operating system version, other frameworks, ... -->
</code></pre>
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
## PR Checklist
Please check if your PR fulfills the following requirements:
- [ ] The commit message follows our guidelines: https://github.com/LokiJS-Forge/LokiDB/blob/master/CONTRIBUTING.md#commit
- [ ] Tests for the changes have been added (for bug fixes / features)
- [ ] Docs have been added / updated (for bug fixes / features)
## PR Type
What kind of change does this PR introduce?
<!-- Please check the one that applies to this PR using "x". -->
```
[ ] Bugfix
[ ] Feature
[ ] Code style update (formatting, local variables)
[ ] Refactoring (no functional changes, no api changes)
[ ] Build related changes
[ ] CI related changes
[ ] Documentation content changes
[ ] Other... Please describe:
```
## What is the current behavior?
<!-- Please describe the current behavior that you are modifying, or link to a relevant issue. -->
Issue Number: N/A
## What is the new behavior?
## Does this PR introduce a breaking change?
```
[ ] Yes
[ ] No
```
<!-- If this PR contains a breaking change, please describe the impact and migration path for existing applications below. -->
## Other information
================================================
FILE: .gitignore
================================================
# IDE
.idea/
# NODE
node_modules/
# Tests
coverage/
.nyc_output
# Typescript
.ts/
# Build artifacts
build/
dist/packages-dist/
packages/**/*.html
site/
docs/api/
================================================
FILE: .travis.yml
================================================
language: python
python:
- "3.5"
node_js:
- "10"
dist: trusty
sudo: required
env:
global:
- GIT_NAME: Travis CI
- GIT_EMAIL: builds@travis-ci.org
- GIT_BRANCH: master
services:
- elasticsearch
addons:
chrome: stable
before_install:
- pip3 install mkdocs
- pip3 install mkdocs-material
script:
- npm install
- PATH=${PATH}:\.\/node_modules\/\.bin/
- npm run lint
- npm test
- codecov
- npm run docs
- mkdocs build
- npm run build
- npm run build -- --dist
- npm install --prefix integration
- npm run test:integration
after_success:
- npm run deploy
================================================
FILE: CHANGELOG.md
================================================
<a name="2.1.0"></a>
# [2.1.0](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0...2.1.0) (2020-08-23)
### Features
* **fts:** support optional, empty or number fields ([#181](https://github.com/LokiJS-Forge/LokiDB/issues/181)) ([57e2ff8](https://github.com/LokiJS-Forge/LokiDB/commit/57e2ff8))
<a name="2.0.0"></a>
# [2.0.0](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0-beta.9...2.0.0) (2020-08-22)
### Bug Fixes
* **persistence:** ignore error if database is not found on autoload ([#179](https://github.com/LokiJS-Forge/LokiDB/issues/179)) ([d1703c6](https://github.com/LokiJS-Forge/LokiDB/commit/d1703c6))
<a name="2.0.0-beta.9"></a>
# [2.0.0-beta.9](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0-beta.8...2.0.0-beta.9) (2020-02-07)
### Bug Fixes
* **loki:** unique search with no matching entry should not fail ([#172](https://github.com/LokiJS-Forge/LokiDB/issues/172)) ([fd2c7d9](https://github.com/LokiJS-Forge/LokiDB/commit/fd2c7d9))
* **loki:** use global.proceas in getENV ([#170](https://github.com/LokiJS-Forge/LokiDB/issues/170)) ([a65e668](https://github.com/LokiJS-Forge/LokiDB/commit/a65e668))
<a name="2.0.0-beta.8"></a>
# [2.0.0-beta.8](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0-beta.7...2.0.0-beta.8) (2018-09-14)
### Bug Fixes
* **loki:** define nested properties on rollback transaction ([#149](https://github.com/LokiJS-Forge/LokiDB/issues/149)) ([9e06e91](https://github.com/LokiJS-Forge/LokiDB/commit/9e06e91))
### Features
* **loki:** remove binary index ([#146](https://github.com/LokiJS-Forge/LokiDB/issues/146)) ([1fb99f2](https://github.com/LokiJS-Forge/LokiDB/commit/1fb99f2))
* **loki:** user definable comparators and operator packages ([#152](https://github.com/LokiJS-Forge/LokiDB/issues/152)) ([5c14bc2](https://github.com/LokiJS-Forge/LokiDB/commit/5c14bc2))
<a name="2.0.0-beta.7"></a>
# [2.0.0-beta.7](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0-beta.6...2.0.0-beta.7) (2018-06-27)
### Bug Fixes
* **full-text-search:** apply bool query boost to subquery results ([#122](https://github.com/LokiJS-Forge/LokiDB/issues/122)) ([5548fe5](https://github.com/LokiJS-Forge/LokiDB/commit/5548fe5))
* **full-text-search:** handle not and filter bool queries right ([#128](https://github.com/LokiJS-Forge/LokiDB/issues/128)) ([98d0cd8](https://github.com/LokiJS-Forge/LokiDB/commit/98d0cd8))
* **loki:** fix autosave and autoload of the database ([#112](https://github.com/LokiJS-Forge/LokiDB/issues/112)) ([ef260fd](https://github.com/LokiJS-Forge/LokiDB/commit/ef260fd))
* **loki:** when cloning, meta will be applied correctly and clones emitted ([#111](https://github.com/LokiJS-Forge/LokiDB/issues/111)) ([d287a2d](https://github.com/LokiJS-Forge/LokiDB/commit/d287a2d)), closes [techfort/LokiJS#666](https://github.com/techfort/LokiJS/issues/666)
### Features
* improve type notation ([#109](https://github.com/LokiJS-Forge/LokiDB/issues/109)) ([3b60c9f](https://github.com/LokiJS-Forge/LokiDB/commit/3b60c9f))
* **full-text-search:** allow number or string as document id ([#115](https://github.com/LokiJS-Forge/LokiDB/issues/115)) ([1d81e25](https://github.com/LokiJS-Forge/LokiDB/commit/1d81e25))
* **full-text-search:** export function analyze ([#102](https://github.com/LokiJS-Forge/LokiDB/issues/102)) ([c1dd78c](https://github.com/LokiJS-Forge/LokiDB/commit/c1dd78c))
* **full-text-search:** if elasticsearch is not available, disable its unit test ([#98](https://github.com/LokiJS-Forge/LokiDB/issues/98)) ([a1c7d8d](https://github.com/LokiJS-Forge/LokiDB/commit/a1c7d8d))
* **full-text-search:** implement conditional minimum should match parameter ([#129](https://github.com/LokiJS-Forge/LokiDB/issues/129)) ([baa6311](https://github.com/LokiJS-Forge/LokiDB/commit/baa6311))
* **full-text-search:** make analyzers classes instead of objects ([#123](https://github.com/LokiJS-Forge/LokiDB/issues/123)) ([1959688](https://github.com/LokiJS-Forge/LokiDB/commit/1959688))
<a name="2.0.0-beta.6"></a>
# [2.0.0-beta.6](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0-beta.5...2.0.0-beta.6) (2018-03-23)
For a better distinction, the library has been renamed to LokiDB.
The repository is now located under https://github.com/LokiJS-Forge/LokiDB
The npm packages can be found under the organization scope @lokidb.
## Commit Summary
### Bug Fixes
* **full-text-search:** fix fuzzy's prefix length, edit distance and idf ([#68](https://github.com/LokiJS-Forge/LokiDB/issues/68)) ([da06836](https://github.com/LokiJS-Forge/LokiDB/commit/da06836))
* **full-text-search:** rename field option "name" to "field" ([#67](https://github.com/LokiJS-Forge/LokiDB/issues/67)) ([ff74219](https://github.com/LokiJS-Forge/LokiDB/commit/ff74219))
* **loki:** fix a autosave race condition when using asynchronous adapter ([#79](https://github.com/LokiJS-Forge/LokiDB/issues/79)) ([db26d02](https://github.com/LokiJS-Forge/LokiDB/commit/db26d02))
* **loki:** fix binary index in batch updates when not cloning ([#78](https://github.com/LokiJS-Forge/LokiDB/issues/78)) ([8081799](https://github.com/LokiJS-Forge/LokiDB/commit/8081799))
### Features
* **full-text-search:** remove query builder ([#73](https://github.com/LokiJS-Forge/LokiDB/issues/73)) ([84757ab](https://github.com/LokiJS-Forge/LokiDB/commit/84757ab))
* **full-text-search:** remove unnecessary array query ([#75](https://github.com/LokiJS-Forge/LokiDB/issues/75)) ([4ff5165](https://github.com/LokiJS-Forge/LokiDB/commit/4ff5165))
* **full-text-search:** replace the old "tokenizer" class with an analyzer interface ([#76](https://github.com/LokiJS-Forge/LokiDB/issues/76)) ([2d44384](https://github.com/LokiJS-Forge/LokiDB/commit/2d44384))
* **full-text-search:** return score result as an equivalent array to result set data ([#69](https://github.com/LokiJS-Forge/LokiDB/issues/69)) ([7ea17c0](https://github.com/LokiJS-Forge/LokiDB/commit/7ea17c0))
* **loki:** add diagnostic function to test binary index validity ([#85](https://github.com/LokiJS-Forge/LokiDB/issues/85)) ([d611722](https://github.com/LokiJS-Forge/LokiDB/commit/d611722))
* **loki:** add option to disable meta property for documents added to a collection ([#80](https://github.com/LokiJS-Forge/LokiDB/issues/80)) ([1a49470](https://github.com/LokiJS-Forge/LokiDB/commit/1a49470))
* **loki:** add simplified javascript comparisons $jgt, $jgte, $jlt, $jlte, $jbetween ([#87](https://github.com/LokiJS-Forge/LokiDB/issues/87)) ([32e4b1e](https://github.com/LokiJS-Forge/LokiDB/commit/32e4b1e))
* **loki:** change and improve nested property support ([#81](https://github.com/LokiJS-Forge/LokiDB/issues/81)) ([2730284](https://github.com/LokiJS-Forge/LokiDB/commit/2730284))
* **loki:** return an existing collection if a collection with the same name already exists ([#77](https://github.com/LokiJS-Forge/LokiDB/issues/77)) ([75afd67](https://github.com/LokiJS-Forge/LokiDB/commit/75afd67))
* **loki:** simplesort leverages binary indices better when filtered ([#83](https://github.com/LokiJS-Forge/LokiDB/issues/83)) ([4d1b25b](https://github.com/LokiJS-Forge/LokiDB/commit/4d1b25b))
<a name="2.0.0-beta.5"></a>
# [2.0.0-beta.5](https://github.com/LokiJS-Forge/LokiJS2/compare/2.0.0-beta.4...2.0.0-beta.5) (2018-01-02)
### Bug Fixes
* **full-text-search-language:** add missing function export ([#64](https://github.com/LokiJS-Forge/LokiJS2/issues/64)) ([9b926e2](https://github.com/LokiJS-Forge/LokiJS2/commit/9b926e2))
### Features
* improve typings ([#62](https://github.com/LokiJS-Forge/LokiJS2/issues/62)) ([b44f550](https://github.com/LokiJS-Forge/LokiJS2/commit/b44f550))
* **full-text-search:** add an optional score explanation ([#65](https://github.com/LokiJS-Forge/LokiJS2/issues/65)) ([9fde195](https://github.com/LokiJS-Forge/LokiJS2/commit/9fde195))
* **memory-storage:** move memory storage to a separate package ([#63](https://github.com/LokiJS-Forge/LokiJS2/issues/63)) ([7cea02a](https://github.com/LokiJS-Forge/LokiJS2/commit/7cea02a))
<a name="2.0.0-beta.4"></a>
# [2.0.0-beta.4](https://github.com/LokiJS-Forge/LokiJS2/compare/2.0.0-beta.3...2.0.0-beta.4) (2017-12-01)
### Features
* **full-text-search:** make index Unicode safe and improve fuzzy performance ([#55](https://github.com/LokiJS-Forge/LokiJS2/issues/55)) ([f1dea05](https://github.com/LokiJS-Forge/LokiJS2/commit/f1dea05))
<a name="2.0.0-beta.3"></a>
# [2.0.0-beta.3](https://github.com/LokiJS-Forge/LokiJS2/compare/2.0.0-beta.2...2.0.0-beta.3) (2017-11-26)
### Bug Fixes
* coverage ([#42](https://github.com/LokiJS-Forge/LokiJS2/issues/42)) ([3509429](https://github.com/LokiJS-Forge/LokiJS2/commit/3509429))
* **full-text-search:** fix fuzzy extended to withdraw wrong results ([#51](https://github.com/LokiJS-Forge/LokiJS2/issues/51)) ([4d493ac](https://github.com/LokiJS-Forge/LokiJS2/commit/4d493ac))
* **loki:** cloning method for specific classes ([#30](https://github.com/LokiJS-Forge/LokiJS2/issues/30)) ([4f4a182](https://github.com/LokiJS-Forge/LokiJS2/commit/4f4a182))
* **loki:** fix error if passed parameters are not serializable for transform ([#43](https://github.com/LokiJS-Forge/LokiJS2/issues/43)) ([dde34ed](https://github.com/LokiJS-Forge/LokiJS2/commit/dde34ed))
* **loki:** implement deep clone as default clone option ([#44](https://github.com/LokiJS-Forge/LokiJS2/issues/44)) ([2f3b718](https://github.com/LokiJS-Forge/LokiJS2/commit/2f3b718))
### Features
* **full-text-search:** add full-text-search as separate package ([#35](https://github.com/LokiJS-Forge/LokiJS2/issues/35)) ([14b9947](https://github.com/LokiJS-Forge/LokiJS2/commit/14b9947))
* **full-text-search:** english and german language support ([3a93477](https://github.com/LokiJS-Forge/LokiJS2/commit/3a93477))
* **full-text-search:** implement extended fuzzy ([#47](https://github.com/LokiJS-Forge/LokiJS2/issues/47)) ([0579026](https://github.com/LokiJS-Forge/LokiJS2/commit/0579026))
* **loki:** add 'dataOptions' to eqJoin ([#33](https://github.com/LokiJS-Forge/LokiJS2/issues/33)) ([efa450e](https://github.com/LokiJS-Forge/LokiJS2/commit/efa450e))
* **loki:** add optional flag for Changes API to limit update operation output to modified properties only ([#29](https://github.com/LokiJS-Forge/LokiJS2/issues/29)) ([a8abe99](https://github.com/LokiJS-Forge/LokiJS2/commit/a8abe99))
* **loki:** allow sorting on nested properties ([#31](https://github.com/LokiJS-Forge/LokiJS2/issues/31)) ([9b426a4](https://github.com/LokiJS-Forge/LokiJS2/commit/9b426a4))
* **loki:** chained/transform map op now accepts 'dataOptions' for clone/removeMeta ([#34](https://github.com/LokiJS-Forge/LokiJS2/issues/34)) ([67d61ac](https://github.com/LokiJS-Forge/LokiJS2/commit/67d61ac))
* **loki:** make Resultset and DynamicView sortable by full-text-search scoring ([#45](https://github.com/LokiJS-Forge/LokiJS2/issues/45)) ([0a5b946](https://github.com/LokiJS-Forge/LokiJS2/commit/0a5b946))
* **loki:** rename collection ([#32](https://github.com/LokiJS-Forge/LokiJS2/issues/32)) ([745e025](https://github.com/LokiJS-Forge/LokiJS2/commit/745e025))
* integrate full-text-search to loki (insert/update/remove + search) ([8fbc174](https://github.com/LokiJS-Forge/LokiJS2/commit/8fbc174))
* move to typescript ([#36](https://github.com/LokiJS-Forge/LokiJS2/issues/36)) ([d47f190](https://github.com/LokiJS-Forge/LokiJS2/commit/d47f190))
<a name="2.0.0-beta.2"></a>
# [2.0.0-beta.2](https://github.com/LokiJS-Forge/LokiJS2/compare/2.0.0-beta.1...2.0.0-beta.2) (2017-09-21)
<a name="2.0.0-beta.1"></a>
# 2.0.0-beta.1 (2017-09-21)
### Features
* **fs-storage:** add fs storage as separate package ([#19](https://github.com/LokiJS-Forge/LokiJS2/issues/19)) ([ec2e523](https://github.com/LokiJS-Forge/LokiJS2/commit/ec2e523))
* **indexed-storage:** add indexed storage as separate package ([#20](https://github.com/LokiJS-Forge/LokiJS2/issues/20)) ([1150029](https://github.com/LokiJS-Forge/LokiJS2/commit/1150029))
* **local-storage:** add local storage as separate package ([#18](https://github.com/LokiJS-Forge/LokiJS2/issues/18)) ([548abfe](https://github.com/LokiJS-Forge/LokiJS2/commit/548abfe))
* **loki:** add lokijs as core package ([#9](https://github.com/LokiJS-Forge/LokiJS2/issues/9)) ([f670ea0](https://github.com/LokiJS-Forge/LokiJS2/commit/f670ea0))
* **partitioning-adapter:** add partitioning-adapter as separate package ([#14](https://github.com/LokiJS-Forge/LokiJS2/issues/14)) ([c6b18ca](https://github.com/LokiJS-Forge/LokiJS2/commit/c6b18ca))
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at lutztonineubert@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/
================================================
FILE: CONTRIBUTING.md
================================================
<!-- This page is a modified version of [Angular's CONTRIBUTING.md](https://github.com/angular/angular/blob/master/CONTRIBUTING.md). -->
# Contributing to LokiDB
We would love for you to contribute to LokiDB and help make it even better than it is
today! As a contributor, here are the guidelines we would like you to follow:
- [Code of Conduct](#coc)
- [Question or Problem?](#question)
- [Issues and Bugs](#issue)
- [Feature Requests](#feature)
- [Submission Guidelines](#submit)
- [Coding Rules](#rules)
- [Test LokiDB](#develop)
## <a name="coc"></a> Code of Conduct
Help us keep LokiDB open and inclusive. Please read and follow our [Code of Conduct][coc].
## <a name="question"></a> Got a Question or Problem?
Please ask your questions tagged with `lokidb` at [Stack Overflow][stackoverflow].
If you would like to chat about the questions in real-time, you can reach out via [our gitter channel][gitter].
## <a name="issue"></a> Found a Bug?
If you find a bug in the source code, you can help us by
[submitting an issue](#submit-issue) to our [GitHub Repository][github]. Even better, you can
[submit a Pull Request](#submit-pr) with a fix.
## <a name="feature"></a> Missing a Feature?
You can *request* a new feature by [submitting an issue](#submit-issue) to our GitHub
Repository. If you would like to *implement* a new feature, please submit an issue with
a proposal for your work first, to be sure that we can use it.
## <a name="submit"></a> Submission Guidelines
### <a name="submit-issue"></a> Submitting an Issue
Before you submit an issue, please search the issue tracker, maybe an issue for your problem already exists and the discussion might inform you of workarounds readily available.
We want to fix all the issues as soon as possible, but before fixing a bug we need to reproduce and confirm it. In order to reproduce bugs we will systematically ask you to provide a minimal reproduction scenario using http://plnkr.co. Having a live, reproducible scenario gives us wealth of important information without going back & forth to you with additional questions like:
- version of LokiDB used
- 3rd-party libraries and their versions
- and most importantly - a use-case that fails
A minimal reproduce scenario using http://plnkr.co/ allows us to quickly confirm a bug (or point out coding problem) as well as confirm that we are fixing the right problem. If plunker is not a suitable way to demonstrate the problem (for example for issues related to our npm packaging), please create a standalone git repository demonstrating the problem.
We will be insisting on a minimal reproduce scenario in order to save maintainers time and ultimately be able to fix more bugs. Interestingly, from our experience users often find coding problems themselves while preparing a minimal plunk. We understand that sometimes it might be hard to extract essentials bits of code from a larger code-base but we really need to isolate the problem before we can fix it.
Unfortunately we are not able to investigate / fix bugs without a minimal reproduction, so if we don't hear back from you we are going to close an issue that don't have enough info to be reproduced.
You can file new issues by filling out our [new issue form][new-issue].
### <a name="submit-pr"></a> Submitting a Pull Request (PR)
Before you submit your Pull Request (PR) consider the following guidelines:
* Search [GitHub][pulls] for an open or closed PR that relates to your submission. You don't want to duplicate effort.
* Create your patch, **including appropriate test cases**.
* Follow our [Coding Rules](#rules).
* Run the full LokiDB test suite, as described in the [developer documentation][dev-doc],
and ensure that all tests pass.
* Commit your changes using a descriptive commit message that follows our
[commit message conventions](#commit). Adherence to these conventions
is necessary because release notes are automatically generated from these messages.
* In GitHub, send a pull request to `LokiDB:master`.
* If we suggest changes then:
* Make the required updates.
* Re-run the LokiDB test suites to ensure tests are still passing.
That's it! Thank you for your contribution!
## <a name="rules"></a> Coding Rules
To ensure consistency throughout the source code, keep these rules in mind as you are working:
* All features or bug fixes **must be tested** by one or more specs (unit-tests).
* All public API methods **must be documented**. (Details TBC).
* We use a consistent code formatting. An automated formatter is available, see the [developer guideline][dev-doc].
## <a name="commit"></a> Commit Message Guidelines
We have very precise rules over how our git commit messages can be formatted. This leads to **more
readable messages** that are easy to follow when looking through the **project history**. But also,
we use the git commit messages to **generate the LokiDB change log**.
### Commit Message Format
Each commit message consists of a **header**, a **body** and a **footer**. The header has a special
format that includes a **type**, a **scope** and a **subject**:
```
<type>(<scope>): <subject>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>
```
The **header** is mandatory and the **scope** of the header is optional.
Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
to read on GitHub as well as in various git tools.
Footer should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.
Samples: (even more [samples][commits])
```
docs(changelog): update change log to beta.5
```
```
fix(release): need to depend on latest rxjs and zone.js
The version in our package.json gets copied to the one we publish, and users need the latest of these.
```
### Revert
If 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 <hash>.`, where the hash is the SHA of the commit being reverted.
### Type
Must be one of the following:
* **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
* **ci**: Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
* **docs**: Documentation only changes
* **feat**: A new feature
* **fix**: A bug fix
* **perf**: A code change that improves performance
* **refactor**: A code change that neither fixes a bug nor adds a feature
* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
* **test**: Adding missing tests or correcting existing tests
### Scope
The scope should be the name of the npm package affected (as perceived by person reading changelog generated from commit messages.
The following is the list of supported scopes:
* **loki**: The LokiDB database.
* **partitioning-adapter**: The partitioning adapter.
* **local-storage**: The local storage adapter.
* **indexed-storage**: The indexed db storage adapter.
* **fs-storage**: The file system storage adapter.
* **memory-storage**: The in-memory storage adapter.
* **full-text-search**: The full-text search engine.
* **full-text-search-language**: The language analyzer utility package.
* **full-text-search-language-de**: The german language analyzer.
* **full-text-search-language-en**: The english language analyzer.
There are currently a few exceptions to the "use package name" rule:
* **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.
* none/empty string: useful for `style`, `test` and `refactor` changes that are done across all packages (e.g. `style: add missing semicolons`)
### Subject
The subject contains succinct description of the change:
* use the imperative, present tense: "change" not "changed" nor "changes"
* don't capitalize first letter
* no dot (.) at the end
### Body
Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
The body should include the motivation for the change and contrast this with previous behavior.
### Footer
The footer should contain any information about **Breaking Changes** and is also the place to
reference GitHub issues that this commit **Closes**.
**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.
[coc]: https://github.com/LokiJS-Forge/LokiDB/blob/master/CODE_OF_CONDUCT.md
[dev-doc]: https://github.com/LokiJS-Forge/LokiDB/blob/master/DEVELOPER.md
[github]: https://github.com/LokiJS-Forge/LokiDB
[new-issue]: https://github.com/LokiJS-Forge/LokiDB/issues/new
[pulls]: https://github.com/LokiJS-Forge/LokiDB/pulls
[commit]: https://github.com/LokiJS-Forge/LokiDB/commits/master
[gitter]: https://gitter.im/techfort/LokiDB
[plunker]: http://plnkr.co/edit
[stackoverflow]: http://stackoverflow.com/questions/tagged/lokidb?sort=newest
================================================
FILE: DEVELOPER.md
================================================
<!-- This page is a modified version of [Angular](https://github.com/angular/angular/blob/master/docs/DEVELOPER.md). -->
# Building and testing LokiDB
This document describes how to set up your development environment to build and test LokiDB.
* [Prerequisite software](#prerequisite-software)
* [Running tests](#running-tests)
* [Formatting your source code](#formatting-your-source-code)
* [Building LokiDB](#building-lokidb)
See the [contribution guidelines][contribution] if you'd like to contribute to LokiDB.
## Prerequisite software
Before you can build and test LokiDB, you must install and configure the
following products on your development machine:
* [Git](http://git-scm.com) and/or the **GitHub app** (for [Mac](http://mac.github.com) or
[Windows](http://windows.github.com)); [GitHub's Guide to Installing
Git](https://help.github.com/articles/set-up-git) is a good source of information.
* [Node.js](http://nodejs.org), (version `>=7.0.0`) which is used to run tests and generate distributable files.
We also use Node's Package Manager, `npm`(version `>=4.0.0`), which comes with Node.
Depending on your system, you can install Node either from source or as a pre-packaged bundle.
* [Elasticsearch](https://www.elastic.co/downloads/elasticsearch) which is used to unit test LokiDB's full text search.
## Running tests
To run tests:
```shell
$ npm run test # Run all LokiDB tests
$ npm run test:web # Run tests only in web browser
$ npm run test:node # Run tests only in node
```
All the tests are executed on our Continuous Integration infrastructure and a PR could only be merged once the tests pass.
## Formatting your source code
LokiDB 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.
You can check that your code is properly formatted and adheres to coding style by running:
``` shell
$ npm run lint
```
You can automatically format your code by running:
``` shell
$ npm run lint:fix
```
## Building LokiDB
To build LokiDB, run:
``` shell
$ npm run build
```
[eslint]: https://eslint.org/
[contribution]: https://github.com/LokiJS-Forge/LokiDB/blob/master/CONTRIBUTING.md
================================================
FILE: LICENSE
================================================
This text consists of three parts:
Part I: Remarks regarding the license given in
Part II: MIT License
Part III: Apache License
-------------------------------------------------------------------------------
Part I:
LokiDB is mostly distributed under the MIT License.
Except the following packages:
@lokidb/full-text-search
- Apache License (https://lucene.apache.org/)
- Apache License (https://www.elastic.co/)
-------------------------------------------------------------------------------
Part II:
MIT License
Copyright (c) 2015-2018 Joe Minichino <joe.minichino@gmail.com>
David Easterday <admin@obeliskos.com>
Toni Neubert <lutztonineubert@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
Part III:
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
================================================
FILE: README.md
================================================
[![npm status][npm]][npm-url]
[![build status][build]][build-url]
[![coverage status][coverage]][coverage-url]
# LokiDB
LokiDB is a document oriented database written in TypeScript.
Its purpose is to store javascript objects as documents in a blazing fast nosql fashion and retrieve them with a similar mechanism.
LokiDB is the official successor of [LokiJS][lokijs-url].
## Install
Install with npm:
```bash
npm install @lokidb/loki
```
## Documentation
Check out our interactive [documentation](https://LokiJS-Forge.github.io/LokiDB/).
## Plugins
### Storage and Adapter
|Name|Description|
|:---|:----------|
|[@lokidb/fs-storage][fs-storage-npm-url] | A persistence adapter which persists to node fs module storage. |
|[@lokidb/local-storage][local-storage-npm-url] | A persistence adapter which persists to web browser's local storage. |
|[@lokidb/indexed-storage][indexed-storage-npm-url] | A persistence adapter which persists to web browser's indexed db storage. |
|[@lokidb/memory-storage][memory-storage-npm-url] | A persistence adapter which persists to memory. |
|[@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.|
### Full-Text Search
|Name|Description|
|:---|:----------|
|[@lokidb/full-text-search][full-text-search-npm-url] | A full-text search engine. |
|[@lokidb/full-text-search-language][full-text-search-language-npm-url] | A language analyzer utility package. |
|[@lokidb/full-text-search-language-de][full-text-search-language-de-npm-url] | ![flag][full-text-search-language-de-flag] A german language analyzer. |
|[@lokidb/full-text-search-language-en][full-text-search-language-en-npm-url] | ![flag][full-text-search-language-en-flag] An english language analyzer. |
[build]: https://travis-ci.org/LokiJS-Forge/LokiDB.svg?branch=master
[build-url]: https://travis-ci.org/LokiJS-Forge/LokiDB
[coverage]: https://codecov.io/gh/LokiJS-Forge/LokiDB/branch/master/graph/badge.svg
[coverage-url]: https://codecov.io/gh/LokiJS-Forge/LokiDB/branch/master
[lokijs-url]: https://github.com/techfort/LokiJS
[npm]: https://img.shields.io/npm/v/@lokidb/loki.svg
[npm-url]: https://www.npmjs.com/package/@lokidb/loki
[fs-storage]: https://github.com/LokiJS-Forge/LokiDB
[fs-storage-npm-url]: https://www.npmjs.com/package/@lokidb/fs-storage
[local-storage]: https://github.com/LokiJS-Forge/LokiDB
[local-storage-npm-url]: https://www.npmjs.com/package/@lokidb/local-storage
[indexed-storage]: https://github.com/LokiJS-Forge/LokiDB
[indexed-storage-npm-url]: https://www.npmjs.com/package/@lokidb/indexed-storage
[memory-storage]: https://github.com/LokiJS-Forge/LokiDB
[memory-storage-npm-url]: https://www.npmjs.com/package/@lokidb/memory-storage
[partitioning-adapter]: https://github.com/LokiJS-Forge/LokiDB
[partitioning-adapter-npm-url]: https://www.npmjs.com/package/@lokidb/partitioning-adapter
[full-text-search]: https://github.com/LokiJS-Forge/LokiDB
[full-text-search-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search
[full-text-search-language]: https://github.com/LokiJS-Forge/LokiDB
[full-text-search-language-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search-language
[full-text-search-language-de]: https://github.com/LokiJS-Forge/LokiDB
[full-text-search-language-de-flag]: https://raw.githubusercontent.com/stevenrskelton/flag-icon/master/png/16/country-4x3/de.png
[full-text-search-language-de-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search-language-de
[full-text-search-language-en]: https://github.com/LokiJS-Forge/LokiDB
[full-text-search-language-en-npm-url]: https://www.npmjs.com/package/@lokidb/full-text-search-language-en
[full-text-search-language-en-flag]: https://raw.githubusercontent.com/stevenrskelton/flag-icon/master/png/16/country-4x3/us.png
================================================
FILE: benchmark/benchmark.js
================================================
/**
* Core, "single object lookup" benchmarks
*/
let Loki = require('../build/packages/loki/lokidb.loki.js').default,
crypto = require("crypto");
/**
* Generates a random string using node crypto library which is less memory 'leaky'
*/
function genRandomVal() {
return crypto.randomBytes(50).toString('hex');
}
/**
* Helper method for instantiating a loki database
* @param {*} mode
*/
function createDatabase(mode) {
let tdb = new Loki("temp.db");
let coll;
switch (mode) {
case "avl":
coll = tdb.addCollection('perfcoll', {
rangedIndexes: {
"customId": { indexTypeName: "avl", comparatorName: "js" }
}
});
break;
case "unique":
coll = tdb.addCollection('perfcoll', {
unique: ['customId']
});
break;
case "none":
default:
coll = tdb.addCollection('perfcoll');
break;
}
return tdb;
}
/**
* Helper method for populating a collection
* @param {*} db
* @param {*} count
*/
function populateDatabase(db, count) {
let coll = db.getCollection("perfcoll");
// populate collection
let idxbuf = [];
let customIdx, v1;
for (let idx = 0; idx < count; idx++) {
customIdx = count - idx;
idxbuf.push(customIdx);
v1 = genRandomVal();
coll.insert({
customId: customIdx,
val: v1,
val2: "more data 1234567890"
});
}
return idxbuf;
}
/**
* Benchmarks collection.by() performance with unique index
* @param {*} count
* @param {*} multiple
*/
function benchUniquePerf(count, multiple) {
let udb = createDatabase("unique");
let uniquecoll = udb.getCollection('perfcoll');
let v1, idxbuf = [];
for (let idx = 0; idx < count; idx++) {
v1 = genRandomVal();
uniquecoll.insert({
customId: (count - idx),
val: v1,
val2: "more data 1234567890"
});
idxbuf.push(count - idx);
}
let start, end;
let totalTimes = [];
let totalMS = 0.0;
let customIdx, result;
for (let m = 0; m < multiple; m++) {
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf[idx];
start = process.hrtime();
result = uniquecoll.by('customId', customIdx);
end = process.hrtime(start);
totalTimes.push(end);
if (result.customId !== customIdx) {
console.log("(perfUnique) object retrieved does match custom id");
}
}
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = multiple * count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("coll.by() : " + totalMS + "ms (" + rate + " ops/s) " + multiple*count + " iterations, " + count + " docs x " + multiple);
};
/**
* Benchmarks collection.get() performance
* @param {*} count number of documents to insert into collection
* @param {*} multiple number of times to repeat get() for each document
*/
function testperfGet(count, multiple) {
let gdb = createDatabase("none");
let coll = gdb.getCollection('perfcoll');
let start, end;
let totalTimes = [];
let totalMS = 0.0;
let customIdx, v1, obj = {}, idxbuf = [];
for (let idx = 0; idx < count; idx++) {
v1 = genRandomVal();
obj = coll.insert({
customId: (count - idx),
val: v1,
val2: "more data 1234567890"
});
idxbuf.push(obj.$loki);
}
let result;
for (let m = 0; m < multiple; m++) {
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf[idx];
start = process.hrtime();
result = coll.get(customIdx);
end = process.hrtime(start);
totalTimes.push(end);
if (result.$loki !== customIdx) {
console.log("(perfGet) object retrieved does match get id");
}
}
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = multiple * count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("coll.get() : " + totalMS + "ms (" + rate + " ops/s) " + multiple*count + " iterations, " + count + " docs x " + multiple);
}
/**
* Benchmark collection find() performance
* @param {*} mode Index Mode ("none", "unique", "avl")
* @param {*} count Document count to populate collection with
* @param {*} multiple Used to repeat finding each document this number of times
*/
function testperfFind(mode, count, multiple) {
multiple = multiple || 1;
let fdb = createDatabase(mode);
let idxbuf = populateDatabase(fdb, count);
let coll = fdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
let results;
for (let m = 0; m < multiple; m++) {
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf[idx];
start = process.hrtime();
results = coll.find({
'customId': customIdx
});
end = process.hrtime(start);
totalTimes.push(end);
if (results.length !== 1) {
console.log("(perfFind) received " + results.length + "instead of 1 matches!");
}
}
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = multiple * count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("coll.find() : " + totalMS + "ms (" + rate + " ops/s) " + multiple * count + " iterations, " + count + " docs x " + multiple);
}
/**
* Resultset benchmark
* @param {*} mode
* @param {*} count
*/
function testperfRS(mode, count, multiple) {
multiple = multiple || 1;
let rsdb = createDatabase(mode);
let idxbuf = populateDatabase(rsdb, count);
let coll = rsdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
let customIdx, results;
for (let m = 0; m < multiple; m++) {
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf[idx];
start = process.hrtime();
results = coll.chain().find({
'customId': customIdx
}).data();
end = process.hrtime(start)
totalTimes.push(end);
if (results.length !== 1) {
console.log("(perfRS) received " + results.length + "instead of 1 matches!");
}
}
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = multiple * count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("resultset chained find() : " + totalMS + "ms (" + rate + " ops/s) " + multiple * count + " iterations, " + count + " docs x " + multiple);
}
/**
* Benchmark dynamic view performance
* @param {*} mode
* @param {*} count
* @param {*} multiple
*/
function testperfDV(mode, count, multiple) {
multiple = multiple || 1;
let dvdb = createDatabase(mode);
let idxbuf = populateDatabase(dvdb, count);
let coll = dvdb.getCollection("perfcoll");
let start, end;
let start2, end2, totalTime2 = 0.0;
let totalTimes = [];
let totalTimes2 = [];
let totalMS = 0;
let totalMS2 = 0;
let customIdx, dv, results;
for (let m = 0; m < multiple; m++) {
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf[idx];
start = process.hrtime();
dv = coll.addDynamicView("perfview");
dv.applyFind({
'customId': customIdx
});
results = dv.data();
end = process.hrtime(start);
totalTimes.push(end);
// test speed of repeated query on an already set up dynamicview
start2 = process.hrtime();
results = dv.data();
end2 = process.hrtime(start2);
totalTimes2.push(end2);
coll.removeDynamicView("perfview");
}
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
totalMS2 += totalTimes2[idx][0] * 1e3 + totalTimes2[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
totalMS2 = totalMS2.toFixed(2);
let rate = multiple * count * 1000 / totalMS;
let rate2 = multiple * count * 1000 / totalMS2;
rate = rate.toFixed(2);
rate2 = rate2.toFixed(2);
console.log("loki dynamic view first find : " + totalMS + "ms (" + rate + " ops/s) " + multiple * count + " iterations, " + count + " docs x " + multiple);
console.log("loki dynamic view subsequent finds : " + totalMS2 + "ms (" + rate2 + " ops/s) " + multiple * count + " iterations, " + count + " docs x " + multiple);
}
/**
* Attempt to free up global variables and invoke node garbage collector (if enabled)
*/
function cleanup() {
if (global.gc) {
global.gc()
}
}
let corePerf = [
() => testperfGet(200000, 20),
() => benchUniquePerf(200000, 20)
];
let nonIndexedSteps = [
() => testperfFind("none", 5000, 8),
() => testperfRS("none", 5000, 8),
() => testperfDV("none", 5000, 8)
];
let nonIndexedStepsHigh = [
() => testperfFind("none", 10000, 1),
() => testperfRS("none", 10000, 1),
() => testperfDV("none", 10000, 1)
];
let avlIndexSteps = [
() => testperfFind("avl", 20000, 20),
() => testperfRS("avl", 20000, 20),
() => testperfDV("avl", 20000, 20)
];
let avlIndexStepsHigh = [
() => testperfFind("avl", 200000, 2),
() => testperfRS("avl", 200000, 2),
() => testperfDV("avl", 200000, 2)
];
let perfGroups = [
{ name: "Benchmarking Core Id lookup performance", steps: corePerf },
{ name: "Benchmarking NON-INDEX query performance (Lower doc count)", steps: nonIndexedSteps },
{ name: "Benchmarking NON-INDEX query performance (Higher doc count)", steps: nonIndexedStepsHigh },
{ name: "Benchmarking AVL TREE INDEX query performance (Lower doc count)", steps: avlIndexSteps },
{ name: "Benchmarking AVL TREE INDEX query performance (Higher doc count)", steps: avlIndexStepsHigh }
];
/**
* Executes steps within a benchmark group, pausing in between steps.
* Once the benchmark group steps are depleted, we initiate next group.
* @param {*} steps
*/
function execSteps(steps) {
// if we are finished with this group's steps...
if (steps.length === 0) {
// wait a few seconds in between benchmark groups
setTimeout(execGroups, 4000);
return;
}
let s = steps.shift();
s();
setTimeout(() => { execSteps(steps); }, 1000);
}
/**
* Kicks off a group of benchmarks, cleaning up in between
*/
function execGroups() {
let g = perfGroups.shift();
if (!g) return;
cleanup();
console.log("");
console.log("## " + g.name + " ##");
console.log("");
execSteps(g.steps);
}
console.log("");
console.log("Note: run 'npm run build' before benchmarking after getting latest or modifying code");
console.log("");
if (!global.gc) {
console.warn("##");
console.warn("## IMPORTANT! : For accuracy of results, launch node with --expose-gc flag");
console.warn("##");
}
execGroups();
================================================
FILE: benchmark/benchmark_indexes.js
================================================
/**
* This module is to be used to benchmark loki binary index lifecycle
*
* Attempt to simulate and benchmark effects of various rebuild strategies on
* insert, find, remove, and update to be used to instrument refactorings/optimizations.
*
* Since a given index type may prioritize lookups/finds over maintenance of insert/update/remove ops,
* the 'Nightmare' tests attempt to pair a find along with insert/update/removes. The resulting
* times tend to average out this bias to allow examining overall performance for scale.
*
* Currently, this benchmark will compare the following index options :
* - Unindexed
* - Adaptive Binary Indices (Lazy benchmarks can be uncommented if you wish those as well)
* - AVL Indexes based on self-balancing AVL binary search trees
*/
let Loki = require('../build/packages/loki/lokidb.loki.js').default,
crypto = require("crypto"); // for less 'leaky' random string generation
/**
* Generate random string using node cryto lib for less memory 'leaky' behavior than js string construction
*/
function genRandomVal() {
return crypto.randomBytes(50).toString('hex');
}
/**
* Helper method to shuffle array
* @param {*} array
*/
function shuffle(array) {
let currentIndex = array.length, temporaryValue, randomIndex;
// While there remain elements to shuffle...
while (0 !== currentIndex) {
// Pick a remaining element...
randomIndex = Math.floor(Math.random() * currentIndex);
currentIndex -= 1;
// And swap it with the current element.
temporaryValue = array[currentIndex];
array[currentIndex] = array[randomIndex];
array[randomIndex] = temporaryValue;
}
return array;
};
/**
* Helper method to convert number of bytes into more readable representation.
* @param {*} bytes
* @param {*} decimals
*/
function formatBytes(bytes, decimals) {
if (bytes == 0) return '0 Byte';
let k = 1000; // or 1024 for binary
let dm = decimals + 1 || 3;
let sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
let i = Math.floor(Math.log(bytes) / Math.log(k));
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}
/**
* Logs memory usage info to console
* @param {*} msg
*/
function logMemoryUsage(msg) {
let pmu = process.memoryUsage();
console.log(msg + " => rss : " + formatBytes(pmu.rss) + " heapTotal : " + formatBytes(pmu.heapTotal) + " heapUsed : " + formatBytes(pmu.heapUsed));
}
/**
* Helper method for instantiating a loki database
* @param {*} mode indexing mode ("none", "avl")
*/
function createDatabase(mode) {
let tdb = new Loki("temp.db");
let coll;
switch (mode) {
case "avl":
coll = tdb.addCollection('perfcoll', {
rangedIndexes: {
"customId": { indexTypeName: "avl", comparatorName: "js" }
}
});
break;
case "none":
default:
coll = tdb.addCollection('perfcoll');
break;
}
return tdb;
}
/**
* Helper method for populating a collection
* @param {*} db loki database instance containing collection to populate
* @param {*} count number of documents to insert
*/
function populateDatabase(db, count) {
let coll = db.getCollection("perfcoll");
// populate collection
let idxbuf = [];
let customIdx, v1;
for (let idx = 0; idx < count; idx++) {
customIdx = count - idx;
idxbuf.push(customIdx);
v1 = genRandomVal();
coll.insert({
customId: customIdx,
val: v1,
val2: "more data 1234567890"
});
}
return idxbuf;
}
/**
* Profiles memory usage for unindexed and avl indexed collections
* @param {*} mode indexing mode ("none", "avl")
* @param {*} count
*/
function profileDatabaseMemory(mode, count) {
let mdb = createDatabase(mode);
populateDatabase(mdb, count);
let coll = mdb.getCollection("perfcoll");
let id, v1;
for (let idx = 0; idx < 100000; idx++) {
id = count - idx;
v1 = genRandomVal();
coll.insert({
customId: id,
val1: v1,
val2: "more data 1234567890"
});
}
logMemoryUsage(mode);
}
/**
* Benchmarks insertion rates for unindexed and avl indexed collections
* @param {*} mode indexing mode ("none", "avl")
* @param {*} count
*/
function profileInsertion(mode, count) {
let mdb = createDatabase(mode);
let coll = mdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
// populate collection manually instead of helper since we won't retain idxbuf
let customIdx, v1;
for (let idx = 0; idx < count; idx++) {
customIdx = count - idx;
v1 = genRandomVal();
start = process.hrtime();
coll.insert({
customId: customIdx,
val: v1,
val2: "more data 1234567890"
});
end = process.hrtime(start);
totalTimes.push(end);
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("insertion rate (" + mode + ") : " + totalMS + "ms (" + rate + " ops/s) " + count + " documents");
}
/**
* Benchmarks find performance for given document count (not multiplied to show raw ms perf)
* @param {*} mode indexing mode ("none", "avl")
* @param {*} count
*/
function perfFind(mode, count) {
let fdb = createDatabase(mode);
let idxbuf = populateDatabase(fdb, count);
let coll = fdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
let customIdx, results;
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf[idx];
start = process.hrtime();
results = coll.find({
'customId': customIdx
});
end = process.hrtime(start);
totalTimes.push(end);
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("random coll.find() : " + totalMS + "ms (" + rate + " ops/s) " + count + " iterations");
}
/**
* Benchmarks interlacing insert + find (on indexed column) to measure index thrashing
* @param {*} mode indexing mode ("none", "avl")
* @param {*} count
*/
function perfFindInterlacedInserts(mode, count) {
let fdb = createDatabase(mode);
let idxbuf = [];
let coll = fdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
let customIdx, results;
for (let idx = 0; idx < count; idx++) {
customIdx = count - idx;
start = process.hrtime();
// insert record with id outside range of pre-populated records
coll.insert({
customId: customIdx,
val: 999,
val2: 999,
val3: "more data 1234567890"
});
// do quick find of object just inserted
results = coll.find({
'customId': customIdx
});
end = process.hrtime(start);
totalTimes.push(end);
if (results.length !== 1 || results[0].customId !== customIdx) {
console.log("(interlaced inserts) unexpected results")
}
}
if (coll.find().length !== count) {
console.log("(interlaced inserts) unexpected total inserted document count");
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("interlaced inserts + coll.find() : " + totalMS + "ms (" + rate + " ops/s) " + count + " iterations");
}
/**
* Benchmarks interlacing find + remove (on indexed column) to measure index thrashing
* @param {*} mode indexing mode ("none", "avl")
* @param {*} count
*/
function perfFindInterlacedRemoves(mode, count, multiple) {
let fdb = createDatabase(mode);
let idxbuf = populateDatabase(fdb, count);
let coll = fdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
let removeId, result;
for (let idx = 0; idx < count; idx++) {
removeId = idxbuf.pop();
start = process.hrtime();
result = coll.findOne({
'customId': removeId
});
coll.remove(result);
end = process.hrtime(start);
totalTimes.push(end);
}
if (coll.find().length !== 0) {
console.log("(interlaces removes) unexpected final doc count");
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("interlaced removes + coll.find() : " + totalMS + "ms (" + rate + " ops/s) " + count + " iterations");
}
/**
* Benchmarks interlacing find + update (on indexed column) to measure index thrashing
* @param {*} mode indexing mode ("none", "avl")
* @param {*} count number of interlaced finds+updates to perform
*/
function perfFindInterlacesUpdates(mode, count) {
let fdb = createDatabase(mode);
let idxbuf = populateDatabase(fdb, count);
let coll = fdb.getCollection("perfcoll");
let start, end;
let totalTimes = [];
let totalMS = 0;
let customIdx, newIdx, result;
for (let idx = 0; idx < count; idx++) {
customIdx = idxbuf.pop();
newIdx = count + idx;
start = process.hrtime();
// lookup next doc
result = coll.findOne({
'customId': customIdx
});
// update doc, modifying the field (potentially) being indexed
result.customId = newIdx;
coll.update(result);
end = process.hrtime(start);
totalTimes.push(end);
}
if (coll.find().length !== count) {
console.log("(interlaced updates) unexpected final doc count");
}
for (let idx = 0; idx < totalTimes.length; idx++) {
totalMS += totalTimes[idx][0] * 1e3 + totalTimes[idx][1] / 1e6;
}
totalMS = totalMS.toFixed(2);
let rate = count * 1000 / totalMS;
rate = rate.toFixed(2);
console.log("interlaced updates + coll.find() : " + totalMS + "ms (" + rate + " ops/s) " + count + " iterations");
}
/**
* Attempt to free up global variables and invoke node garbage collector (if enabled)
*/
function cleanup() {
if (global.gc) {
global.gc();
}
}
let memoryProfileSteps = [
cleanup,
() => logMemoryUsage("baseline"),
() => profileDatabaseMemory("unindexed", 10000),
cleanup,
() => logMemoryUsage("baseline"),
() => profileDatabaseMemory("avl", 10000)
];
let insertionProfileSteps = [
// Unindexed Inserts
cleanup,
() => console.log("no index"),
() => profileInsertion("none", 100000),
// AVL indexed inserts
cleanup,
() => console.log("avl tree index"),
() => profileInsertion("avl", 100000)
];
let nightmareUnindexedLowSteps = [
() => {
console.log("");
console.log("------------ Beginning Nightmare Benchmarks ------------");
console.log("Nightmare tests combine a find() with either an insert(), update(), or remove()");
console.log("to remove any bias and show weaknesses that each indexing strategy may be leveraging, ");
console.log("such as placing all emphasis on find() performance to detriment of index maintenance costs.");
console.log("");
},
() => {
console.log("Perf: Unindexed Nightmare (Lower Scale @ 5,000 docs/iterations) ------------------------");
createDatabase("none");
},
cleanup,
() => perfFind("none", 5000),
cleanup,
() => perfFindInterlacedInserts("none", 5000),
cleanup,
() => perfFindInterlacedRemoves("none", 5000),
cleanup,
() => perfFindInterlacesUpdates("none", 5000)
];
let nightmareUnindexedHighSteps = [
() => {
console.log("Perf: Unindexed Nightmare (Higher Scale @ 10,000 docs/iterations) ------------------------");
createDatabase("none");
},
cleanup,
() => perfFind("none", 10000),
cleanup,
() => perfFindInterlacedInserts("none", 10000),
cleanup,
() => perfFindInterlacedRemoves("none", 10000),
cleanup,
() => perfFindInterlacesUpdates("none", 10000),
];
let nightmareAvlLowSteps = [
() => console.log("Perf: AVL Indexed Nightmare (Lower Scale @ 40,000 docs/iterations) ---"),
cleanup,
() => perfFind("avl", 40000),
cleanup,
() => perfFindInterlacedInserts("avl", 40000),
cleanup,
() => perfFindInterlacedRemoves("avl", 40000),
cleanup,
() => perfFindInterlacesUpdates("avl", 40000),
];
let nightmareAvlHighSteps = [
() => console.log("Perf: AVL Indexed Nightmare (Higher Scale @ 100,000 docs/iterations) ---"),
cleanup,
() => perfFind("avl", 100000),
cleanup,
() => perfFindInterlacedInserts("avl", 100000),
cleanup,
() => perfFindInterlacedRemoves("avl", 100000),
cleanup,
() => perfFindInterlacesUpdates("avl", 100000)
];
let perfGroups = [
//{ name: "Memory Profiling of database with various indexing", steps: memoryProfileSteps },
//{ name: "Document Insertion rates with various indexes", steps: insertionProfileSteps },
{ name: "Nightmare Unindexed (Low Range)", steps: nightmareUnindexedLowSteps },
{ name: "Nightmare Unindexed (High Range)", steps: nightmareUnindexedHighSteps },
{ name: "Nightmare AVL Index (Low Range)", steps: nightmareAvlLowSteps },
{ name: "Nightmare AVL Index (High Range)", steps: nightmareAvlHighSteps }
];
function execSteps(steps) {
if (steps.length === 0) {
setTimeout(execGroups, 4000);
return;
}
let s = steps.shift();
s();
setTimeout(() => { execSteps(steps); }, 1000);
}
function execGroups() {
let g = perfGroups.shift();
if (!g) return;
cleanup();
console.log("");
console.log("## " + g.name + " ##");
console.log("");
execSteps(g.steps);
}
if (!global.gc) {
console.warn("##");
console.warn("## IMPORTANT! : For accuracy of results, launch node with --expose-gc flag");
console.warn("##");
}
console.log("");
console.log("Note: run 'npm run build' before benchmarking after getting latest or modifying code");
console.log("");
execGroups();
================================================
FILE: config/jasmine.json
================================================
{
"spec_dir": "packages/*/spec",
"spec_files": [
"generic/**/*.spec.[jt]s",
"node/**/*.spec.[jt]s"
],
"helpers": [
"../../../node_modules/ts-node/register/index.js",
"../../../node_modules/jasmine-expect/index.js",
"../../common/spec/helper/**/*helper.[jt]s",
"helper/**/*.[jt]s"
],
"stopSpecOnExpectationFailure": false,
"random": false
}
================================================
FILE: config/karma.config.js
================================================
/* global process, require, module, require */
const path = require("path");
module.exports = function (config) {
const configuration = {
frameworks: ["jasmine", "jasmine-matchers"],
browsers: ["ChromeHeadless"],
basePath: "../",
files: [
{pattern: "packages/*/spec/generic/**/*.spec.ts", watched: false},
{pattern: "packages/*/spec/web/**/*.spec.ts", watched: false}
],
preprocessors: {
"packages/*/spec/generic/**/*.spec.ts": ["webpack"],
"packages/*/spec/web/**/*.spec.ts": ["webpack"]
},
// coverage reporter generates the coverage
reporters: ["progress", "coverage-istanbul"],
coverageIstanbulReporter: {
dir: "coverage/karma/",
reports: ["text-summary", "json"],
fixWebpackSourcePaths: true
},
mime: {
"text/x-typescript": ["ts"]
},
webpack: {
mode: "development",
stats: 'errors-only',
resolve: {
extensions: [".ts"],
},
devtool: "source-map",
module: {
rules: [
{
enforce: "pre",
test: /\.ts$/,
loader: "tslint-loader",
exclude: /node_modules/,
options: {
failOnHint: false,
configFile: path.join(__dirname, "tslint.json"),
}
},
{
test: /\.ts$/,
loader: "ts-loader",
options: {
configFile: path.join(__dirname, "tsconfig.webpack.json")
}
},
{
enforce: "post",
exclude: [
/node_modules/,
/\.spec\.ts$/,
/.*\/spec\/.+\.ts/,
/\.helper\.ts$/,
/.*\/helper\/.+\.ts/
],
loader: "istanbul-instrumenter-loader?esModules=true",
test: /\.ts$/
}
]
}
},
webpackMiddleware: {
logLevel: "warn"
},
plugins: [
"karma-chrome-launcher",
"karma-coverage-istanbul-reporter",
"karma-jasmine",
"karma-jasmine-matchers",
"karma-webpack",
],
};
config.set(configuration);
};
================================================
FILE: config/nycrc.json
================================================
{
"reporter": [
"text-summary",
"html"
],
"report-dir": "./coverage/",
"temp-directory": "./coverage/"
}
================================================
FILE: config/nycrc.node.json
================================================
{
"extension": [
".ts"
],
"reporter": [
"text-summary",
"json"
],
"exclude": [
"**/*.helper.[jt]s",
"**/*.spec.[jt]s",
"**/spec/**/*.[jt]s"
],
"report-dir": "./coverage/node/"
}
================================================
FILE: config/tsconfig.tslint.json
================================================
{
"compileOnSave": false,
"compilerOptions": {
"outDir": "../types/",
"sourceMap": true,
"declaration": true,
"moduleResolution": "classic",
"strictPropertyInitialization": true,
"alwaysStrict": true,
"noImplicitAny": true,
"noImplicitReturns": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"suppressImplicitAnyIndexErrors": true,
"target": "es6",
"lib": [
"es2017"
],
"typeRoots": [
"node_modules/@types"
],
"types": [
"jasmine",
"jasmine-expect",
"node"
]
},
"include": [
"../packages/**/*.ts"
]
}
================================================
FILE: config/tsconfig.webpack.json
================================================
{
"compileOnSave": false,
"compilerOptions": {
"outDir": "../types/",
"sourceMap": true,
"declaration": true,
"moduleResolution": "classic",
"strictPropertyInitialization": true,
"alwaysStrict": true,
"noImplicitAny": true,
"noImplicitReturns": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"suppressImplicitAnyIndexErrors": true,
"target": "es6",
"lib": [
"es2017",
"dom"
],
"typeRoots": [
"node_modules/@types"
],
"types": [
"jasmine",
"jasmine-expect",
"node"
]
},
"include": [
"../packages/*/src/**/*.ts"
]
}
================================================
FILE: config/tslint.json
================================================
{
"rulesDirectory": [
"../node_modules/vrsource-tslint-rules/rules",
"../node_modules/tslint-eslint-rules/dist/rules"
],
"extends": [
"tslint-eslint-rules"
],
"rules": {
"no-console": [true, "log"],
"no-duplicate-imports": true,
"no-duplicate-variable": true,
"no-jasmine-focus": true,
"no-var-keyword": true,
"semicolon": [true],
"variable-name": [true, "ban-keywords"],
"no-inner-declarations": [true, "function"],
"quotemark": [true, "double"],
"eofline": true,
"ter-indent": [true, 2, {
"SwitchCase": 1
}],
"whitespace": [true, "check-branch", "check-decl", "check-operator", "check-module", "check-separator",
"check-rest-spread", "check-type", "check-type", "check-typecast", "check-type-operator", "check-preblock"],
"no-trailing-whitespace": true
}
}
================================================
FILE: config/webpack-config-creator.js
================================================
/* global __dirname, module, require */
const path = require("path");
module.exports = (options) => {
if (options.entry === undefined) {
throw Error("options.entry must be specified.")
}
if (options.filename === undefined) {
throw Error("options.Filename must be specified.")
}
if (options.library === undefined) {
throw Error("options.library must be specified.")
}
return {
mode: "production",
entry: options.entry,
output: {
filename: options.filename,
library: options.library,
libraryTarget: "umd2",
umdNamedDefine: true,
globalObject: "typeof self !== 'undefined' ? self : this"
},
externals: options.externals,
resolve: {
extensions: [".ts"]
},
devtool: "source-map",
module: {
rules: [
{
enforce: "pre",
test: /\.ts$/,
loader: "tslint-loader",
exclude: /node_modules/,
options: {
failOnHint: true,
configFile: path.join("config", "tslint.json"),
}
},
{
test: /\.ts$/,
loader: "ts-loader",
options: {
configFile: path.join("config", "tsconfig.webpack.json")
}
}
]
},
optimization: {
minimize: false
},
};
};
================================================
FILE: dist/packages/fs-storage/lokidb.fs-storage.js
================================================
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("fs"));
else if(typeof define === 'function' && define.amd)
define("@lokidb/fs-storage", ["fs"], factory);
else if(typeof exports === 'object')
exports["@lokidb/fs-storage"] = factory(require("fs"));
else
{ root["@lokidb/fs-storage"] = factory(root["fs"]); root["LokiFsStorage"] = root["@lokidb/fs-storage"].default; }
})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE__0__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 3);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE__0__;
/***/ }),
/* 1 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return PLUGINS; });
function getGlobal() {
let glob;
(function (global) {
glob = global;
})(global !== undefined && global || this);
return glob;
}
function create() {
const global = getGlobal();
const sym = Symbol.for("LOKI");
if (global[sym] === undefined) {
global[sym] = {};
}
return global[sym];
}
/**
* @hidden
*/
const PLUGINS = create();
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(2)))
/***/ }),
/* 2 */
/***/ (function(module, exports) {
var g;
// This works in non-strict mode
g = (function() {
return this;
})();
try {
// This works if eval is allowed (see CSP)
g = g || Function("return this")() || (1, eval)("this");
} catch (e) {
// This works if the window reference is available
if (typeof window === "object") g = window;
}
// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}
module.exports = g;
/***/ }),
/* 3 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FSStorage", function() { return FSStorage; });
/* harmony import */ var _common_plugin__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0);
/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
/**
* A loki persistence adapter which persists using node fs module.
*/
class FSStorage {
/**
* Registers the fs storage as plugin.
*/
static register() {
_common_plugin__WEBPACK_IMPORTED_MODULE_0__[/* PLUGINS */ "a"]["FSStorage"] = FSStorage;
}
/**
* Deregisters the fs storage as plugin.
*/
static deregister() {
delete _common_plugin__WEBPACK_IMPORTED_MODULE_0__[/* PLUGINS */ "a"]["FSStorage"];
}
/**
* Load data from file, will throw an error if the file does not exist
* @param {string} dbname - the filename of the database to load
* @returns {Promise} a Promise that resolves after the database was loaded
*/
loadDatabase(dbname) {
return new Promise((resolve, reject) => {
fs__WEBPACK_IMPORTED_MODULE_1__["stat"](dbname, (err, stats) => {
if (!err && stats.isFile()) {
fs__WEBPACK_IMPORTED_MODULE_1__["readFile"](dbname, {
encoding: "utf8"
}, function readFileCallback(err, data) {
if (err) {
reject(err);
}
else {
resolve(data);
}
});
}
else {
reject(null);
}
});
});
}
/**
* Save data to file, will throw an error if the file can't be saved
* might want to expand this to avoid dataloss on partial save
* @param {string} dbname - the filename of the database to load
* @returns {Promise} a Promise that resolves after the database was persisted
*/
saveDatabase(dbname, dbstring) {
const tmpdbname = dbname + "~";
return new Promise((resolve, reject) => {
fs__WEBPACK_IMPORTED_MODULE_1__["writeFile"](tmpdbname, dbstring, (err) => {
if (err) {
reject(err);
}
else {
fs__WEBPACK_IMPORTED_MODULE_1__["rename"](tmpdbname, dbname, (err) => {
if (err) {
reject(err);
}
else {
resolve();
}
});
}
});
});
}
/**
* Delete the database file, will throw an error if the
* file can't be deleted
* @param {string} dbname - the filename of the database to delete
* @returns {Promise} a Promise that resolves after the database was deleted
*/
deleteDatabase(dbname) {
return new Promise((resolve, reject) => {
fs__WEBPACK_IMPORTED_MODULE_1__["unlink"](dbname, function deleteDatabaseCallback(err) {
if (err) {
reject(err);
}
else {
resolve();
}
});
});
}
}
/***/ })
/******/ ]);
});
//# sourceMappingURL=lokidb.fs-storage.js.map
================================================
FILE: dist/packages/fs-storage/types/common/plugin.d.ts
================================================
/**
* @hidden
*/
export declare const PLUGINS: void;
================================================
FILE: dist/packages/fs-storage/types/common/types.d.ts
================================================
/**
* @hidden
*/
import { Loki } from "../loki/src/loki";
export interface StorageAdapter {
loadDatabase(dbname: string): Promise<any>;
saveDatabase?(dbname: string, serialization: string): Promise<void>;
deleteDatabase?(dbname: string): Promise<void>;
mode?: string;
exportDatabase?(dbname: string, dbref: Loki): Promise<void>;
}
export declare type Doc<T extends object = object> = T & {
$loki: number;
meta?: {
created: number;
revision: number;
version: number;
updated?: number;
};
};
export interface Dict<T> {
[index: string]: T;
[index: number]: T;
}
================================================
FILE: dist/packages/fs-storage/types/fs-storage/src/fs_storage.d.ts
================================================
import { StorageAdapter } from "../../common/types";
/**
* A loki persistence adapter which persists using node fs module.
*/
export declare class FSStorage implements StorageAdapter {
/**
* Registers the fs storage as plugin.
*/
static register(): void;
/**
* Deregisters the fs storage as plugin.
*/
static deregister(): void;
/**
* Load data from file, will throw an error if the file does not exist
* @param {string} dbname - the filename of the database to load
* @returns {Promise} a Promise that resolves after the database was loaded
*/
loadDatabase(dbname: string): Promise<any>;
/**
* Save data to file, will throw an error if the file can't be saved
* might want to expand this to avoid dataloss on partial save
* @param {string} dbname - the filename of the database to load
* @returns {Promise} a Promise that resolves after the database was persisted
*/
saveDatabase(dbname: string, dbstring: string): Promise<void>;
/**
* Delete the database file, will throw an error if the
* file can't be deleted
* @param {string} dbname - the filename of the database to delete
* @returns {Promise} a Promise that resolves after the database was deleted
*/
deleteDatabase(dbname: string): Promise<void>;
}
================================================
FILE: dist/packages/fs-storage/types/fs-storage/src/index.d.ts
================================================
import { FSStorage } from "./fs_storage";
export { FSStorage };
export default FSStorage;
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/analyzer.d.ts
================================================
import { CharacterFilter } from "./character_filter";
import { Tokenizer, whitespaceTokenizer } from "./tokenizer";
import { lowercaseTokenFilter, TokenFilter } from "./token_filter";
/**
* A analyzer converts a string into tokens which are added to the inverted index for searching.
*/
export interface Analyzer {
/**
* The character filters of the analyzer.
*/
char_filter?: CharacterFilter[];
/**
* The tokenizer of the analyzer.
*/
tokenizer: Tokenizer;
/**
* The token filters of the analyzer.
*/
token_filter?: TokenFilter[];
}
/**
* Analyzes a given string.
* @param {Analyzer} analyzer - the analyzer
* @param {string} str - the string
* @returns {string[]} - the tokens
*/
export declare function analyze(analyzer: Analyzer, str: string): string[];
/**
* An analyzer with the whitespace tokenizer and the lowercase token filter.
*/
export declare class StandardAnalyzer implements Analyzer {
tokenizer: typeof whitespaceTokenizer;
token_filter: (typeof lowercaseTokenFilter)[];
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/character_filter.d.ts
================================================
/**
* A character filter is used to preprocess a string before it is passed to a tokenizer.
*/
export declare type CharacterFilter = (value: string) => string;
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/token_filter.d.ts
================================================
/**
* A token filter takes tokens from a tokenizer and modify, delete or add tokens.
*/
export declare type TokenFilter = (value: string, index: number, array: string[]) => string;
/**
* Converts a token to lowercase.
* @param {string} token - the token
* @returns {string} - the lowercased token
*/
export declare function lowercaseTokenFilter(token: string): string;
/**
* Converts a token to uppercase.
* @param {string} token - the token
* @returns {string} - the uppercased token
*/
export declare function uppercaseTokenFilter(token: string): string;
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/tokenizer.d.ts
================================================
/**
* A tokenizer splits a string into individual tokens.
*/
export declare type Tokenizer = (value: string) => string[];
/**
* Splits a string at whitespace characters into tokens.
* @param {string} value - the string
* @returns {string[]} - the tokens
*/
export declare function whitespaceTokenizer(value: string): string[];
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/full_text_search.d.ts
================================================
import { InvertedIndex } from "./inverted_index";
import { Dict } from "../../common/types";
import { Query } from "./query_types";
import { Scorer } from "./scorer";
import { Analyzer } from "./analyzer/analyzer";
export declare class FullTextSearch {
private _id;
private _docs;
private _idxSearcher;
private _invIdxs;
/**
* Registers the full-text search as plugin.
*/
static register(): void;
/**
* Initialize the full-text search for the given fields.
* @param {object[]} fieldOptions - the field options
* @param {string} fieldOptions.field - the name of the property field
* @param {boolean=true} fieldOptions.store - flag to indicate if the full-text search should be stored on serialization or
* rebuild on deserialization
* @param {boolean=true} fieldOptions.optimizeChanges - flag to optimize updating and deleting of documents
* (requires more memory but performs faster)
* @param {Analyzer} fieldOptions.analyzer - an analyzer for the field
* @param {string} [id] - the property name of the document index
*/
constructor(fieldOptions?: FullTextSearch.FieldOptions[], id?: string);
addDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;
removeDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;
updateDocument(doc: object, id?: InvertedIndex.DocumentIndex): void;
clear(): void;
search(query: Query): Scorer.ScoreResults;
toJSON(): FullTextSearch.Serialization;
static fromJSONObject(serialized: FullTextSearch.Serialization, analyzers?: Dict<Analyzer>): FullTextSearch;
}
export declare namespace FullTextSearch {
interface FieldOptions extends InvertedIndex.FieldOptions {
field: string;
}
interface Serialization {
id: string;
ii: Dict<InvertedIndex.Serialization>;
}
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/automaton.d.ts
================================================
/**
* Transition with dest, min and max.
* @hidden
*/
export declare type Transition = [number, number, number];
/**
* @type {number}
* @hidden
*/
export declare const MIN_CODE_POINT = 0;
/**
* @type {number}
* @hidden
*/
export declare const MAX_CODE_POINT = 1114111;
/**
* From org/apache/lucene/util/automaton/Automaton.java
* @hidden
*/
export declare class Automaton {
private _stateTransitions;
private _accept;
private _nextState;
private _currState;
private _transitions;
constructor();
isAccept(n: number): boolean;
createState(): number;
setAccept(state: number, accept: boolean): void;
finishState(): void;
private _finishCurrentState();
getStartPoints(): number[];
step(state: number, label: number): number;
getNumStates(): number;
addTransition(source: number, dest: number, min: number, max: number): void;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
================================================
import { ParametricDescription } from "./parametric_description";
/**
* From org/apache/lucene/util/automaton/Lev1TParametricDescription.java
* @hidden
*/
export declare class Lev1TParametricDescription extends ParametricDescription {
constructor(w: number);
transition(absState: number, position: number, vector: number): number;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
================================================
import { ParametricDescription } from "./parametric_description";
/**
* From org/apache/lucene/util/automaton/Lev2TParametricDescription.java
* @hidden
*/
export declare class Lev2TParametricDescription extends ParametricDescription {
constructor(w: number);
transition(absState: number, position: number, vector: number): number;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
================================================
import { Automaton } from "./automaton";
/**
* From org/apache/lucene/util/automaton/LevenshteinAutomata.java
* @hidden
*/
export declare class LevenshteinAutomata {
private _word;
private _numRanges;
private _rangeLower;
private _rangeUpper;
private _description;
private _alphabet;
private _editDistance;
constructor(input: number[], editDistance: number);
/**
* Transforms the NDFA to a DFA.
* @returns {Automaton}
*/
toAutomaton(): Automaton;
private _getVector(x, pos, end);
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/long.d.ts
================================================
/**
* Class supports 64Bit integer operations.
* A cut-down version of dcodeIO/long.js.
* @hidden
*/
export declare class Long {
private _low;
private _high;
constructor(low?: number, high?: number);
/**
* Returns this long with bits arithmetically shifted to the right by the given amount.
* @param {number} numBits - number of bits
* @returns {Long} the long
*/
shiftRight(numBits: number): Long;
/**
* Returns this long with bits arithmetically shifted to the left by the given amount.
* @param {number} numBits - number of bits
* @returns {Long} the long
*/
shiftLeft(numBits: number): Long;
/**
* Returns the bitwise AND of this Long and the specified.
* @param {Long} other - the other Long
* @returns {Long} the long
*/
and(other: Long): Long;
/**
* Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
* @returns {number}
*/
toInt(): number;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts
================================================
import { Long } from "./long";
/**
* From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescription
* @hidden
*/
export declare class ParametricDescription {
protected _w: number;
private _n;
private _minErrors;
constructor(w: number, n: number, minErrors: number[]);
/**
* Return the number of states needed to compute a Levenshtein DFA
*/
size(): number;
/**
* Returns true if the <code>state</code> in any Levenshtein DFA is an accept state (final state).
*/
isAccept(absState: number): boolean;
/**
* Returns the position in the input word for a given <code>state</code>.
* This is the minimal boundary for the state.
*/
getPosition(absState: number): number;
static unpack(data: Long[], index: number, bitsPerValue: number): number;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts
================================================
import { Automaton } from "./automaton";
/**
* From org/apache/lucene/util/automaton/RunAutomaton.java
* @hidden
*/
export declare class RunAutomaton {
private _points;
private _accept;
private _transitions;
private _classmap;
constructor(automaton: Automaton);
getCharClass(c: number): number;
step(state: number, c: number): number;
isAccept(state: number): boolean;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/index.d.ts
================================================
import { FullTextSearch } from "./full_text_search";
import { analyze, StandardAnalyzer } from "./analyzer/analyzer";
import { whitespaceTokenizer } from "./analyzer/tokenizer";
import { lowercaseTokenFilter, uppercaseTokenFilter } from "./analyzer/token_filter";
export { FullTextSearch, analyze, StandardAnalyzer, whitespaceTokenizer, lowercaseTokenFilter, uppercaseTokenFilter };
export default FullTextSearch;
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/index_searcher.d.ts
================================================
import { Scorer } from "./scorer";
import { InvertedIndex } from "./inverted_index";
import { Query } from "./query_types";
import { Dict } from "../../common/types";
/**
* @hidden
*/
export declare class IndexSearcher {
private _invIdxs;
private _docs;
private _scorer;
/**
* Constructs an index searcher.
* @param {Dict<InvertedIndex>} invIdxs - the inverted indexes
* @param {Set<number>} docs - the ids of the documents
*/
constructor(invIdxs: Dict<InvertedIndex>, docs: Set<InvertedIndex.DocumentIndex>);
search(query: Query): Scorer.ScoreResults;
setDirty(): void;
private _recursive(query, doScoring);
private _getUnique(queries, doScoring, queryResults);
private _getAll(queries, doScoring, queryResults?);
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/inverted_index.d.ts
================================================
import { Analyzer } from "./analyzer/analyzer";
/**
* Converts a string into an array of code points.
* @param str - the string
* @returns {number[]} to code points
* @hidden
*/
export declare function toCodePoints(str: string): number[];
/**
* Inverted index class handles featured text search for specific document fields.
* @hidden
*/
export declare class InvertedIndex {
analyzer: Analyzer;
docCount: number;
docStore: Map<InvertedIndex.DocumentIndex, InvertedIndex.DocStore>;
totalFieldLength: number;
root: InvertedIndex.Index;
private _store;
private _optimizeChanges;
/**
* @param {boolean} [options.store=true] - inverted index will be stored at serialization rather than rebuilt on load
* @param {boolean} [options.optimizeChanges=true] - flag to store additional metadata inside the index for better
* performance if an existing field is updated or removed
* @param {Analyzer} [options.analyzer=] - the analyzer of this inverted index
*/
constructor(options?: InvertedIndex.FieldOptions);
/**
* Adds defined fields of a document to the inverted index.
* @param {string} field - the field to add
* @param {number} docId - the doc id of the field
*/
insert(field: string, docId: InvertedIndex.DocumentIndex): void;
/**
* Removes all relevant terms of a document from the inverted index.
* @param {number} docId - the document.
*/
remove(docId: InvertedIndex.DocumentIndex): void;
/**
* Gets the term index of a term.
* @param {string} term - the term
* @param {object} root - the term index to start from
* @param {number} start - the position of the term string to start from
* @return {object} - The term index or null if the term is not in the term tree.
*/
static getTermIndex(term: number[], root: InvertedIndex.Index, start?: number): InvertedIndex.Index;
/**
* Extends a term index to all available term leafs.
* @param {object} idx - the term index to start from
* @param {number[]} [term=[]] - the current term
* @param {Array} termIndices - all extended indices with their term
* @returns {Array} - Array with term indices and extension
*/
static extendTermIndex(idx: InvertedIndex.Index, term?: number[], termIndices?: InvertedIndex.IndexTerm[]): InvertedIndex.IndexTerm[];
/**
* Serialize the inverted index.
* @returns {{docStore: *, _fields: *, index: *}}
*/
toJSON(): InvertedIndex.Serialization;
/**
* Deserialize the inverted index.
* @param {{docStore: *, _fields: *, index: *}} serialized - The serialized inverted index.
* @param {Analyzer} analyzer[undefined] - an analyzer
*/
static fromJSONObject(serialized: InvertedIndex.Serialization, analyzer?: Analyzer): InvertedIndex;
private static _serializeIndex(idx);
private static _deserializeIndex(serialized);
/**
* Set parent of to each index and regenerate the indexRef.
* @param {Index} index - the index
* @param {Index} parent - the parent
*/
private _regenerate(index, parent);
/**
* Iterate over the whole inverted index and remove the document.
* Delete branch if not needed anymore.
* Function is needed if index is used without optimization.
* @param {Index} idx - the index
* @param {number} docId - the doc id
* @returns {boolean} true if index is empty
*/
private _remove(idx, docId);
}
export declare namespace InvertedIndex {
interface FieldOptions {
store?: boolean;
optimizeChanges?: boolean;
analyzer?: Analyzer;
}
type Index = Map<number, any> & {
dc?: Map<DocumentIndex, number>;
df?: number;
pa?: Index;
};
type IndexTerm = {
index: Index;
term: number[];
};
interface SerializedIndex {
d?: {
df: number;
dc: [DocumentIndex, number][];
};
k?: number[];
v?: SerializedIndex[];
}
type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization = {
_store: false;
_optimizeChanges: boolean;
};
type FullSerialization = {
_store: true;
_optimizeChanges: boolean;
docCount: number;
docStore: [DocumentIndex, DocStore][];
totalFieldLength: number;
root: SerializedIndex;
};
interface DocStore {
fieldLength?: number;
indexRef?: Index[];
}
type DocumentIndex = number | string;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/query_types.d.ts
================================================
/**
* Base query to enable boost to a query type.
*/
export interface BaseQuery<Type> {
type: Type;
boost?: number;
}
/**
* A query which finds documents where a document field contains a term.
*/
export interface TermQuery extends BaseQuery<"term"> {
field: string;
value: string;
}
/**
* A query which finds documents where a document field contains any of the terms.
*/
export interface TermsQuery extends BaseQuery<"terms"> {
field: string;
value: string[];
}
/**
* A query which finds documents where the wildcard term can be applied at an existing document field term.
*/
export interface WildcardQuery extends BaseQuery<"wildcard"> {
field: string;
value: string;
enable_scoring?: boolean;
}
/**
* A query which finds documents where the fuzzy term can be transformed into an existing document field term within a
* given edit distance.
*/
export interface FuzzyQuery extends BaseQuery<"fuzzy"> {
field: string;
value: string;
fuzziness?: 0 | 1 | 2 | "AUTO";
prefix_length?: number;
extended?: boolean;
}
/**
* A query which matches documents containing the prefix of a term inside a field.
*/
export interface PrefixQuery extends BaseQuery<"prefix"> {
field: string;
value: string;
enable_scoring?: boolean;
}
/**
* A query which matches all documents with a given field.
*/
export interface ExistsQuery extends BaseQuery<"exists"> {
field: string;
}
/**
* A query which tokenizes the given text into tokens and performs a sub query for each token. The results are combined
* using a boolean operator.
*/
export interface MatchQuery extends BaseQuery<"match"> {
field: string;
value: string;
minimum_should_match?: number | string;
operator?: "and" | "or";
fuzziness?: 0 | 1 | 2 | "AUTO";
prefix_length?: number;
extended?: boolean;
}
/**
* A query that matches all documents and giving them a constant score equal to the query boost.
*/
export interface MatchQueryAll extends BaseQuery<"match_all"> {
}
/**
* A query that wraps sub queries and returns a constant score equal to the query boost for every document in the filter.
*/
export interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
filter: QueryTypes[];
}
/**
* A query that matches documents matching boolean combinations of sub queries.
*/
export interface BoolQuery extends BaseQuery<"bool"> {
must?: QueryTypes[];
filter?: QueryTypes[];
should?: QueryTypes[];
not?: QueryTypes[];
minimum_should_match?: number | string;
}
/**
* Union type of possible query types.
*/
export declare type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuery | WildcardQuery | FuzzyQuery | MatchQuery | MatchQueryAll | PrefixQuery | ExistsQuery;
/**
* The main query with the actually full-text search query and the scoring parameters.
*/
export interface Query {
query: QueryTypes;
calculate_scoring?: boolean;
explain?: boolean;
bm25?: {
k1: number;
b: number;
};
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search/src/scorer.d.ts
================================================
import { InvertedIndex } from "./inverted_index";
import { Dict } from "../../common/types";
import { Query } from "./query_types";
/**
* @hidden
*/
export declare class Scorer {
private _invIdxs;
private _cache;
constructor(invIdxs: Dict<InvertedIndex>);
setDirty(): void;
score(fieldName: string, boost: number, termIdx: InvertedIndex.Index, doScoring: boolean | null, queryResults: Scorer.QueryResults, term: number[], df?: number): void;
scoreConstant(boost: number, docId: InvertedIndex.DocumentIndex, queryResults: Scorer.QueryResults): Scorer.QueryResults;
finalScore(query: Query, queryResults: Scorer.QueryResults): Scorer.ScoreResults;
private static _calculateFieldLength(fieldLength);
private _getCache(fieldName);
/**
* Returns the idf by either calculate it or use a cached one.
* @param {string} fieldName - the name of the field
* @param {number} docFreq - the doc frequency of the term
* @returns {number} the idf
* @private
*/
private _idf(fieldName, docFreq);
private _avgFieldLength(fieldName);
}
export declare namespace Scorer {
interface IDFCache {
idfs: Dict<number>;
avgFieldLength: number;
}
interface QueryResult {
tf?: number;
idf?: number;
boost: number;
fieldName?: string;
term?: number[];
}
type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
interface BM25Explanation {
boost: number;
score: number;
docID: number;
fieldName: string;
index: string;
idf: number;
tfNorm: number;
tf: number;
fieldLength: number;
avgFieldLength: number;
}
interface ConstantExplanation {
boost: number;
score: number;
}
type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult = {
score: number;
explanation?: ScoreExplanation[];
};
type ScoreResults = Dict<ScoreResult>;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search-language/src/index.d.ts
================================================
export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from "./language";
================================================
FILE: dist/packages/fs-storage/types/full-text-search-language/src/language.d.ts
================================================
export declare function generateTrimmer(wordCharacters: string): (token: string) => string;
export declare function generateStopWordFilter(stopWords: string[]): (token: string) => string;
export declare class Among {
s_size: number;
s: number[];
substring_i: number;
result: number;
method: any;
constructor(s: string, substring_i: number, result: number, method?: any);
}
export declare class SnowballProgram {
current: string;
bra: number;
ket: number;
limit: number;
cursor: number;
limit_backward: number;
constructor();
setCurrent(word: string): void;
getCurrent(): string;
in_grouping(s: number[], min: number, max: number): boolean;
in_grouping_b(s: number[], min: number, max: number): boolean;
out_grouping(s: number[], min: number, max: number): boolean;
out_grouping_b(s: number[], min: number, max: number): boolean;
eq_s(s_size: number, s: string): boolean;
eq_s_b(s_size: number, s: string): boolean;
find_among(v: Among[], v_size: number): number;
find_among_b(v: Among[], v_size: number): number;
replace_s(c_bra: number, c_ket: number, s: string): number;
slice_check(): void;
slice_from(s: string): void;
slice_del(): void;
insert(c_bra: number, c_ket: number, s: string): void;
slice_to(): string;
eq_v_b(s: string): boolean;
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search-language-de/src/german_analyzer.d.ts
================================================
import { Analyzer } from "../../full-text-search/src/analyzer/analyzer";
export declare class GermanAnalyzer implements Analyzer {
tokenizer: (str: string) => string[];
token_filter: ((token: string) => string)[];
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search-language-de/src/index.d.ts
================================================
import { GermanAnalyzer } from "./german_analyzer";
export { GermanAnalyzer };
export default GermanAnalyzer;
================================================
FILE: dist/packages/fs-storage/types/full-text-search-language-en/src/english_analyzer.d.ts
================================================
import { Analyzer } from "../../full-text-search/src/analyzer/analyzer";
export declare class EnglishAnalyzer implements Analyzer {
tokenizer: (str: string) => string[];
token_filter: ((token: string) => string)[];
}
================================================
FILE: dist/packages/fs-storage/types/full-text-search-language-en/src/index.d.ts
================================================
import { EnglishAnalyzer } from "./english_analyzer";
export { EnglishAnalyzer };
export default EnglishAnalyzer;
================================================
FILE: dist/packages/fs-storage/types/indexed-storage/src/index.d.ts
================================================
import { IndexedStorage } from "./indexed_storage";
export { IndexedStorage };
export default IndexedStorage;
================================================
FILE: dist/packages/fs-storage/types/indexed-storage/src/indexed_storage.d.ts
================================================
import { StorageAdapter } from "../../common/types";
/**
* Loki persistence adapter class for indexedDb.
* This class fulfills abstract adapter interface which can be applied to other storage methods.
* Utilizes the included LokiCatalog app/key/value database for actual database persistence.
* IndexedDb storage is provided per-domain, so we implement app/key/value database to
* allow separate contexts for separate apps within a domain.
*/
export declare class IndexedStorage implements StorageAdapter {
private _appname;
private catalog;
/**
* Registers the indexed storage as plugin.
*/
static register(): void;
/**
* Deregisters the indexed storage as plugin.
*/
static deregister(): void;
/**
* @param {string} [appname=loki] - Application name context can be used to distinguish subdomains, "loki" by default
*/
constructor(appname?: string);
/**
* Retrieves a serialized db string from the catalog.
*
* @example
* // LOAD
* var idbAdapter = new LokiIndexedAdapter("finance");
* var db = new loki("test", { adapter: idbAdapter });
* db.base(function(result) {
* console.log("done");
* });
*
* @param {string} dbname - the name of the database to retrieve.
* @returns {Promise} a Promise that resolves after the database was loaded
*/
loadDatabase(dbname: string): Promise<{}>;
/**
* Saves a serialized db to the catalog.
*
* @example
* // SAVE : will save App/Key/Val as "finance"/"test"/{serializedDb}
* let idbAdapter = new LokiIndexedAdapter("finance");
* let db = new loki("test", { adapter: idbAdapter });
* let coll = db.addCollection("testColl");
* coll.insert({test: "val"});
* db.saveDatabase(); // could pass callback if needed for async complete
*
* @param {string} dbname - the name to give the serialized database within the catalog.
* @param {string} dbstring - the serialized db string to save.
* @returns {Promise} a Promise that resolves after the database was persisted
*/
saveDatabase(dbname: string, dbstring: string): Promise<void>;
/**
* Deletes a serialized db from the catalog.
*
* @example
* // DELETE DATABASE
* // delete "finance"/"test" value from catalog
* idbAdapter.deleteDatabase("test", function {
* // database deleted
* });
*
* @param {string} dbname - the name of the database to delete from the catalog.
* @returns {Promise} a Promise that resolves after the database was deleted
*/
deleteDatabase(dbname: string): Promise<void>;
/**
* Removes all database partitions and pages with the base filename passed in.
* This utility method does not (yet) guarantee async deletions will be completed before returning
*
* @param {string} dbname - the base filename which container, partitions, or pages are derived
*/
deleteDatabasePartitions(dbname: string): void;
/**
* Retrieves object array of catalog entries for current app.
*
* @example
* idbAdapter.getDatabaseList(function(result) {
* // result is array of string names for that appcontext ("finance")
* result.forEach(function(str) {
* console.log(str);
* });
* });
*
* @param {function} callback - should accept array of database names in the catalog for current app.
*/
getDatabaseList(callback: (names: string[]) => void): void;
/**
* Allows retrieval of list of all keys in catalog along with size
* @param {function} callback - (Optional) callback to accept result array.
*/
getCatalogSummary(callback: (entry: Entry[]) => void): void;
}
export interface Entry {
app: string;
key: string;
size: number;
}
export default IndexedStorage;
================================================
FILE: dist/packages/fs-storage/types/local-storage/src/index.d.ts
================================================
import { LocalStorage } from "./local_storage";
export { LocalStorage };
export default LocalStorage;
================================================
FILE: dist/packages/fs-storage/types/local-storage/src/local_storage.d.ts
================================================
import { StorageAdapter } from "../../common/types";
/**
* A loki persistence adapter which persists to web browser's local storage object
* @constructor LocalStorageAdapter
*/
export declare class LocalStorage implements StorageAdapter {
/**
* Registers the local storage as plugin.
*/
static register(): void;
/**
* Deregisters the local storage as plugin.
*/
static deregister(): void;
/**
* loadDatabase() - Load data from localstorage
* @param {string} dbname - the name of the database to load
* @returns {Promise} a Promise that resolves after the database was loaded
*/
loadDatabase(dbname: string): Promise<string>;
/**
* saveDatabase() - save data to localstorage, will throw an error if the file can't be saved
* might want to expand this to avoid dataloss on partial save
* @param {string} dbname - the filename of the database to load
* @returns {Promise} a Promise that resolves after the database was saved
*/
saveDatabase(dbname: string, dbstring: string): Promise<void>;
/**
* deleteDatabase() - delete the database from localstorage, will throw an error if it
* can't be deleted
* @param {string} dbname - the filename of the database to delete
* @returns {Promise} a Promise that resolves after the database was deleted
*/
deleteDatabase(dbname: string): Promise<void>;
}
export default LocalStorage;
================================================
FILE: dist/packages/fs-storage/types/loki/src/avl_index.d.ts
================================================
import { IRangedIndex, IRangedIndexRequest } from "./ranged_indexes";
import { ILokiComparer } from "./comparators";
/**
* Treenode type for binary search tree (BST) implementation.
*
* To support duplicates, we may need to either repurpose parent to
* point to 'elder' sibling or add a siblingId to point to owner of
* node represented in tree.
*/
export declare type TreeNode<T> = {
id: number;
value: T;
parent: number | null;
balance: number;
height: number;
left: number | null;
right: number | null;
siblings: number[];
};
export interface ITreeNodeHash<T> {
[id: number]: TreeNode<T>;
}
/**
* LokiDB AVL Balanced Binary Tree Index implementation.
* To support duplicates, we use siblings (array) in tree nodes.
* Basic AVL components guided by William Fiset tutorials at :
* https://github.com/williamfiset/data-structures/blob/master/com/williamfiset/datastructures/balancedtree/AVLTreeRecursive.java
* https://www.youtube.com/watch?v=g4y2h70D6Nk&list=PLDV1Zeh2NRsD06x59fxczdWLhDDszUHKt
*/
export declare class AvlTreeIndex<T> implements IRangedIndex<T> {
name: string;
comparator: ILokiComparer<T>;
nodes: ITreeNodeHash<T>;
apex: number | null;
/**
* Initializes index with property name and a comparer function.
*/
constructor(name: string, comparator: ILokiComparer<T>);
backup(): AvlTreeIndex<T>;
restore(tree: AvlTreeIndex<T>): void;
/**
* Used for inserting a new value into the BinaryTreeIndex
* @param id Unique Id (such as $loki) to associate with value
* @param val Value to be indexed and inserted into binary tree
*/
insert(id: number, val: T): void;
/**
* Recursively inserts a treenode and re-balances if needed.
* @param current
* @param node
*/
insertNode(current: TreeNode<T>, node: TreeNode<T>): number;
/**
* Updates height and balance (calculation) for tree node
* @param node
*/
private updateBalance(node);
/**
* Balance the 'double left-heavy' condition
* @param node
*/
private leftLeftCase(node);
/**
* Balance the '(parent) left heavy, (child) right heavy' condition
* @param node
*/
private leftRightCase(node);
/**
* Balance the 'double right-heavy' condition
* @param node
*/
private rightRightCase(node);
/**
* Balance the '(parent) right heavy, (child) left heavy' condition
* @param node
*/
private rightLeftCase(node);
/**
* Left rotation of node. Swaps right child into current location.
* @param node
*/
private rotateLeft(node);
/**
* Right rotation of node. Swaps left child into current location.
* @param node
*/
private rotateRight(node);
/**
* Diagnostic method for examining tree contents and structure
* @param node
*/
getValuesAsTree(node?: TreeNode<T>): any;
/**
* Updates a value, possibly relocating it, within binary tree
* @param id Unique Id (such as $loki) to associate with value
* @param val New value to be indexed within binary tree
*/
update(id: number, val: T): void;
/**
* Removes a value from the binary tree index
* @param id
*/
remove(id: number): void;
/**
* Recursive node removal and rebalancer
* @param node
* @param val
*/
private removeNode(node, id);
/**
* Utility method for updating a parent's child link when it changes
* @param parentId
* @param oldChildId
* @param newChildId
*/
private updateChildLink(parentId, oldChildId, newChildId);
/**
* When removing a parent with only child, this does simple remap of child to grandParent.
* @param grandParent New parent of 'child'.
* @param parent Node being removed.
* @param child Node to reparent to grandParent.
*/
private promoteChild(parent, child);
/**
* Finds a successor to a node and replaces that node with it.
* @param node
*/
private promoteSuccessor(node);
/**
* Utility method for finding In-Order predecessor to the provided node
* @param node Parent node to find leaf node of greatest 'value'
*/
private findGreaterLeaf(node);
/**
* Utility method for finding In-Order successor to the provided node
* @param node Parent Node to find leaf node of least 'value'
*/
private findLesserLeaf(node);
/**
* Interface method to support ranged queries. Results sorted by index property.
* @param range Options for ranged request.
*/
rangeRequest(range?: IRangedIndexRequest<T>): number[];
/**
* Implements ranged request operations.
* @param node
* @param range
*/
private collateRequest(node, range);
/**
* Used on a branch node to return an array of id within that branch, sorted by their value
* @param node
*/
private collateIds(node);
/**
* Traverses tree to a node matching the provided value.
* @param node
* @param val
*/
/**
* Inline/Non-recusive 'single value' ($eq) lookup.
* Traverses tree to a node matching the provided value.
* @param node
* @param val
*/
private locate(node, val);
/**
* Index integrity check (IRangedIndex interface function)
*/
validateIndex(): boolean;
/**
* Recursive Node validation routine
* @param node
*/
private validateNode(node);
}
================================================
FILE: dist/packages/fs-storage/types/loki/src/clone.d.ts
================================================
export declare type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-recurse";
/**
* @hidden
*/
export declare function clone<T>(data: T, method?: CloneMethod): T;
================================================
FILE: dist/packages/fs-storage/types/loki/src/collection.d.ts
================================================
import { LokiEventEmitter } from "./event_emitter";
import { UniqueIndex } from "./unique_index";
import { ResultSet } from "./result_set";
import { DynamicView } from "./dynamic_view";
import { IRangedIndex } from "./ranged_indexes";
import { CloneMethod } from "./clone";
import { Doc, Dict } from "../../common/types";
import { FullTextSearch } from "../../full-text-search/src/full_text_search";
import { Analyzer } from "../../full-text-search/src/analyzer/analyzer";
/**
* Collection class that handles documents of same type
* @extends LokiEventEmitter
* @param <TData> - the data type
* @param <TNested> - nested properties of data type
*/
export declare class Collection<TData extends object = object, TNested extends object = object, T extends TData & TNested = TData & TNested> extends LokiEventEmitter {
name: string;
_data: Doc<T>[];
private _idIndex;
_rangedIndexes: {
[P in keyof T]?: Collection.RangedIndexMeta;
};
_lokimap: {
[$loki: number]: Doc<T>;
};
_unindexedSortComparator: string;
_defaultLokiOperatorPackage: string;
/**
* Unique constraints contain duplicate object references, so they are not persisted.
* We will keep track of properties which have unique constraints applied here, and regenerate on load.
*/
_constraints: {
unique: {
[P in keyof T]?: UniqueIndex;
};
};
/**
* Transforms will be used to store frequently used query chains as a series of steps which itself can be stored along
* with the database.
*/
_transforms: Dict<Collection.Transform<T>[]>;
/**
* In autosave scenarios we will use collection level dirty flags to determine whether save is needed.
* currently, if any collection is dirty we will autosave the whole database if autosave is configured.
* Defaulting to true since this is called from addCollection and adding a collection should trigger save.
*/
_dirty: boolean;
private _cached;
/**
* Is collection transactional.
*/
private _transactional;
/**
* Options to clone objects when inserting them.
*/
_cloneObjects: boolean;
/**
* Default clone method (if enabled) is parse-stringify.
*/
_cloneMethod: CloneMethod;
/**
* If set to true we will not maintain a meta property for a document.
*/
private _disableMeta;
/**
* Disable track changes.
*/
private _disableChangesApi;
/**
* Disable delta update object style on changes.
*/
_disableDeltaChangesApi: boolean;
/**
* By default, if you insert a document with a Date value for an indexed property, we will convert that value to number.
*/
private _serializableIndexes;
/**
* Name of path of used nested properties.
*/
private _nestedProperties;
/**
* Option to activate a cleaner daemon - clears "aged" documents at set intervals.
*/
_ttl: Collection.TTL;
private _maxId;
private _dynamicViews;
/**
* Changes are tracked by collection and aggregated by the db.
*/
private _changes;
/**
* stages: a map of uniquely identified 'stages', which hold copies of objects to be
* manipulated without affecting the data in the original collection
*/
private _stages;
private _commitLog;
_fullTextSearch: FullTextSearch;
/**
* @param {string} name - collection name
* @param {(object)} [options={}] - a configuration object
* @param {string[]} [options.unique=[]] - array of property names to define unique constraints for
* @param {string[]} [options.exact=[]] - array of property names to define exact constraints for
* @param {RangedIndexOptions} [options.rangedIndexes] - configuration object for ranged indexes
* @param {boolean} [options.asyncListeners=false] - whether listeners are invoked asynchronously
* @param {boolean} [options.disableMeta=false] - set to true to disable meta property on documents
* @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes API
* @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)
* @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user
* @param {boolean} [options.serializableIndexes=true] - converts date values on binary indexed property values are serializable
* @param {string} [options.cloneMethod="deep"] - the clone method
* @param {number} [options.transactional=false] - ?
* @param {number} [options.ttl=] - age of document (in ms.) before document is considered aged/stale.
* @param {number} [options.ttlInterval=] - time interval for clearing out 'aged' documents; not set by default
* @param {string} [options.unindexedSortComparator="js"] "js", "abstract", "abstract-date", "loki" or other registered comparator name
* @param {string} [options.defaultLokiOperatorPackage="js"] "js", "loki", "comparator" (or user defined) query ops package
* @param {FullTextSearch.FieldOptions} [options.fullTextSearch=] - the full-text search options
* @see {@link Loki#addCollection} for normal creation of collections
*/
constructor(name: string, options?: Collection.Options<TData, TNested>);
toJSON(): Collection.Serialized;
static fromJSONObject(obj: Collection.Serialized, options?: Collection.DeserializeOptions): Collection<any, object, any>;
/**
* Adds a named collection transform to the collection
* @param {string} name - name to associate with transform
* @param {array} transform - an array of transformation 'step' objects to save into the collection
*/
addTransform(name: string, transform: Collection.Transform<T>[]): void;
/**
* Retrieves a named transform from the collection.
* @param {string} name - name of the transform to lookup.
*/
getTransform(name: string): Collection.Transform<T>[];
/**
* Updates a named collection transform to the collection
* @param {string} name - name to associate with transform
* @param {object} transform - a transformation object to save into collection
*/
setTransform(name: string, transform: Collection.Transform<T>[]): void;
/**
* Removes a named collection transform from the collection
* @param {string} name - name of collection transform to remove
*/
removeTransform(name: string): void;
private setTTL(age, interval);
/**
* Create a row filter that covers all documents in the collection.
*/
_prepareFullDocIndex(): number[];
/**
* Ensure rangedIndex of a field.
* @param field
* @param indexTypeName
* @param comparatorName
*/
ensureIndex(field: string, indexTypeName?: string, comparatorName?: string): void;
/**
* Ensure rangedIndex of a field.
* @param field Property to create an index on (need to look into contraining on keyof T)
* @param indexTypeName Name of IndexType factory within (global?) hashmap to create IRangedIndex from
* @param comparatorName Name of Comparator within (global?) hashmap
*/
ensureRangedIndex(field: string, indexTypeName?: string, comparatorName?: string): void;
ensureUniqueIndex(field: keyof T): UniqueIndex;
/**
* Quickly determine number of documents in collection (or query)
* @param {object} query - (optional) query object to count results of
* @returns {number} number of documents in the collection
*/
count(query?: ResultSet.Query<Doc<T>>): number;
/**
* Rebuild idIndex
*/
private _ensureId();
/**
* Add a dynamic view to the collection
* @param {string} name - name of dynamic view to add
* @param {object} options - (optional) options to configure dynamic view with
* @param {boolean} [options.persistent=false] - indicates if view is to main internal results array in 'resultdata'
* @param {string} [options.sortPriority=SortPriority.PASSIVE] - the sort priority
* @param {number} options.minRebuildInterval - minimum rebuild interval (need clarification to docs here)
* @returns {DynamicView} reference to the dynamic view added
**/
addDynamicView(name: string, options?: DynamicView.Options): DynamicView<T>;
/**
* Remove a dynamic view from the collection
* @param {string} name - name of dynamic view to remove
**/
removeDynamicView(name: string): void;
/**
* Look up dynamic view reference from within the collection
* @param {string} name - name of dynamic view to retrieve reference of
* @returns {DynamicView} A reference to the dynamic view with that name
**/
getDynamicView(name: string): DynamicView<T>;
/**
* Applies a 'mongo-like' find query object and passes all results to an update function.
* @param {object} filterObject - the 'mongo-like' query object
* @param {function} updateFunction - the update function
*/
findAndUpdate(filterObject: ResultSet.Query<Doc<T>>, updateFunction: (obj: Doc<T>) => any): void;
/**
* Applies a 'mongo-like' find query object removes all documents which match that filter.
* @param {object} filterObject - 'mongo-like' query object
*/
findAndRemove(filterObject: ResultSet.Query<Doc<T>>): void;
/**
* Adds object(s) to collection, ensure object(s) have meta properties, clone it if necessary, etc.
* @param {(object|array)} doc - the document (or array of documents) to be inserted
* @returns {(object|array)} document or documents inserted
*/
insert(doc: TData): Doc<T>;
insert(doc: TData[]): Doc<T>[];
/**
* Adds a single object, ensures it has meta properties, clone it if necessary, etc.
* @param {object} doc - the document to be inserted
* @param {boolean} bulkInsert - quiet pre-insert and insert event emits
* @returns {object} document or 'undefined' if there was a problem inserting it
*/
insertOne(doc: TData, bulkInsert?: boolean): Doc<T>;
/**
* Refers nested properties of an object to the root of it.
* @param {T} data - the object
* @returns {T & TNested} the object with nested properties
* @hidden
*/
_defineNestedProperties<U extends TData>(data: U): U & TNested;
/**
* Empties the collection.
* @param {boolean} [removeIndices=false] - remove indices
*/
clear({removeIndices: removeIndices}?: {
removeIndices?: boolean;
}): void;
/**
* Updates an object and notifies collection that the document has changed.
* @param {object} doc - document to update within the collection
*/
update(doc: Doc<T> | Doc<T>[]): void;
/**
* Add object to collection
*/
private _add(obj);
/**
* Applies a filter function and passes all results to an update function.
* @param {function} filterFunction - the filter function
* @param {function} updateFunction - the update function
*/
updateWhere(filterFunction: (obj: Doc<T>) => boolean, updateFunction: (obj: Doc<T>) => Doc<T>): void;
/**
* Remove all documents matching supplied filter function.
* @param {function} filterFunction - the filter function
*/
removeWhere(filterFunction: (obj: Doc<T>) => boolean): void;
removeDataOnly(): void;
/**
* Remove a document from the collection
* @param {number|object} doc - document to remove from collection
*/
remove(doc: number | Doc<T> | Doc<T>[]): void;
/**
* Returns all changes.
* @returns {Collection.Change[]}
*/
getChanges(): Collection.Change[];
/**
* Enables/disables changes api.
* @param {boolean} disableChangesApi
* @param {boolean} disableDeltaChangesApi
*/
setChangesApi(disableChangesApi: boolean, disableDeltaChangesApi?: boolean): void;
/**
* Clears all the changes.
*/
flushChanges(): void;
private _getObjectDelta(oldObject, newObject);
/**
* Compare changed object (which is a forced clone) with existing object and return the delta
*/
private _getChangeDelta(obj, old);
/**
* Creates a clone of the current status of an object and associates operation and collection name,
* so the parent db can aggregate and generate a changes object for the entire db
*/
private _createChange(name, op, obj, old?);
private _createInsertChange(obj);
private _createUpdateChange(obj, old);
private _insertMetaWithChange(obj);
private _updateMetaWithChange(obj, old);
private _insertMeta(obj);
private _updateMeta(obj);
/**
* Get by Id - faster than other methods because of the searching algorithm
* @param {int} id - $loki id of document you want to retrieve
* @param {boolean} returnPosition - if 'true' we will return [object, position]
* @returns {(object|array|null)} Object reference if document was found, null if not,
* or an array if 'returnPosition' was passed.
*/
get(id: number): Doc<T>;
get(id: number, returnPosition: boolean): Doc<T> | [Doc<T>, number];
/**
* Retrieve doc by Unique index
* @param {string} field - name of uniquely indexed property to use when doing lookup
* @param {any} value - unique value to search for
* @returns {object} document matching the value passed
*/
by(field: keyof T, value: any): Doc<T>;
/**
* Find one object by index property, by property equal to value
* @param {object} query - query object used to perform search with
* @returns {(object|null)} First matching document, or null if none
*/
findOne(query: ResultSet.Query<Doc<T>>): Doc<T>;
/**
* Chain method, used for beginning a series of chained find() and/or view() operations
* on a collection.
*
* @param {array} transform - Ordered array of transform step objects similar to chain
* @param {object} parameters - Object containing properties representing parameters to substitute
* @returns {ResultSet} (this) ResultSet, or data array if any map or join functions where called
*/
chain(transform?: string | Collection.Transform<T>[], parameters?: object): ResultSet<T>;
/**
* Find method, api is similar to mongodb.
* for more complex queries use [chain()]{@link Collection#chain} or [where()]{@link Collection#where}.
* @example {@tutorial Query Examples}
* @param {object} query - 'mongo-like' query object
* @returns {array} Array of matching documents
*/
find(query?: ResultSet.Query<Doc<T>>): Doc<T>[];
/**
* Find object by unindexed field by property equal to value,
* simply iterates and returns the first element matching the query
*/
findOneUnindexed(prop: string, value: any): Doc<T>;
/**
* Transaction methods
*/
/**
* start the transation
*/
startTransaction(): void;
/**
* Commit the transaction.
*/
commit(): void;
/**
* Rollback the transaction.
*/
rollback(): void;
/**
* Query the collection by supplying a javascript filter function.
* @example
* let results = coll.where(function(obj) {
* return obj.legs === 8;
* });
* @param {function} fun - filter function to run against all collection docs
* @returns {array} all documents which pass your filter function
*/
where(fun: (obj: Doc<T>) => boolean): Doc<T>[];
/**
* Map Reduce operation
* @param {function} mapFunction - function to use as map function
* @param {function} reduceFunction - function to use as reduce function
* @returns {data} The result of your mapReduce operation
*/
mapReduce<U1, U2>(mapFunction: (value: Doc<T>, index: number, array: Doc<T>[]) => U1, reduceFunction: (array: U1[]) => U2): U2;
/**
* Join two collections on specified properties
* @param {array} joinData - array of documents to 'join' to this collection
* @param {string} leftJoinProp - property name in collection
* @param {string} rightJoinProp - property name in joinData
* @param {function} mapFun - (Optional) map function to use
* @param dataOptions - options to data() before input to your map function
* @param [dataOptions.removeMeta] - allows removing meta before calling mapFun
* @param [dataOptions.forceClones] - forcing the return of cloned objects to your map object
* @param [dataOptions.forceCloneMethod] - allows overriding the default or collection specified cloning method
* @returns {ResultSet} Result of the mapping operation
*/
eqJoin(joinData: Collection<any> | ResultSet<any> | any[], leftJoinProp: string | ((obj: any) => string), rightJoinProp: string | ((obj: any) => string), mapFun?: (left: any, right: any) => any, dataOptions?: ResultSet.DataOptions): ResultSet<any>;
/**
* (Staging API) create a stage and/or retrieve it
*/
getStage(name: string): any;
/**
* a collection of objects recording the changes applied through a commmitStage
*/
/**
* (Staging API) create a copy of an object and insert it into a stage
*/
stage<F extends TData>(stageName: string, obj: Doc<F>): F;
/**
* (Staging API) re-attach all objects to the original collection, so indexes and views can be rebuilt
* then create a message to be inserted in the commitlog
* @param {string} stageName - name of stage
* @param {string} message
*/
commitStage(stageName: string, message: string): void;
/**
* Returns all values of a field.
* @param {string} field - the field name
* @return {any}: the array of values
*/
extract(field: keyof T): any[];
/**
* Finds the minimum value of a field.
* @param {string} field - the field name
* @return {number} the minimum value
*/
min(field: keyof T): number;
/**
* Finds the maximum value of a field.
* @param {string} field - the field name
* @return {number} the maximum value
*/
max(field: keyof T): number;
/**
* Finds the minimum value and its index of a field.
* @param {string} field - the field name
* @return {object} - index and value
*/
minRecord(field: keyof T): {
index: number;
value: number;
};
/**
* Finds the maximum value and its index of a field.
* @param {string} field - the field name
* @return {object} - index and value
*/
maxRecord(field: keyof T): {
index: number;
value: number;
};
/**
* Returns all values of a field as numbers (if possible).
* @param {string} field - the field name
* @return {number[]} - the number array
*/
extractNumerical(field: keyof T): number[];
/**
* Calculates the average numerical value of a field
* @param {string} field - the field name
* @returns {number} average of property in all docs in the collection
*/
avg(field: keyof T): number;
/**
* Calculate the standard deviation of a field.
* @param {string} field - the field name
* @return {number} the standard deviation
*/
stdDev(field: keyof T): number;
/**
* Calculates the mode of a field.
* @param {string} field - the field name
* @return {number} the mode
*/
mode(field: keyof T): number;
/**
* Calculates the median of a field.
* @param {string} field - the field name
* @return {number} the median
*/
median(field: keyof T): number;
}
export declare namespace Collection {
interface Options<TData extends object, TNested extends object = {}, T extends object = TData & TNested> {
unique?: (keyof T)[];
unindexedSortComparator?: string;
defaultLokiOperatorPackage?: string;
rangedIndexes?: RangedIndexOptions;
serializableIndexes?: boolean;
asyncListeners?: boolean;
disableMeta?: boolean;
disableChangesApi?: boolean;
disableDeltaChangesApi?: boolean;
clone?: boolean;
serializableIndices?: boolean;
cloneMethod?: CloneMethod;
transactional?: boolean;
ttl?: number;
ttlInterval?: number;
nestedProperties?: (keyof TNested | {
name: keyof TNested;
path: string[];
})[];
fullTextSearch?: FullTextSearch.FieldOptions[];
}
interface RangedIndexOptions {
[prop: string]: RangedIndexMeta;
}
interface DeserializeOptions {
retainDirtyFlags?: boolean;
fullTextSearch?: Dict<Analyzer>;
[collName: string]: any | {
proto?: any;
inflate?: (src: object, dest?: object) => void;
};
}
interface BinaryIndex {
dirty: boolean;
values: any;
}
interface RangedIndexMeta {
index?: IRangedIndex<any>;
indexTypeName?: string;
comparatorName?: string;
}
interface Change {
name: string;
operation: string;
obj: any;
}
interface Serialized {
name: string;
unindexedSortComparator: string;
defaultLokiOperatorPackage: string;
_dynamicViews: DynamicView[];
_nestedProperties: {
name: string;
path: string[];
}[];
uniqueNames: string[];
transforms: Dict<Transform[]>;
rangedIndexes: RangedIndexOptions;
_data: Doc<any>[];
idIndex: number[];
maxId: number;
_dirty: boolean;
transactional: boolean;
asyncListeners: boolean;
disableMeta: boolean;
disableChangesApi: boolean;
disableDeltaChangesApi: boolean;
cloneObjects: boolean;
cloneMethod: CloneMethod;
changes: any;
_fullTextSearch: FullTextSearch;
}
interface CheckIndexOptions {
randomSampling?: boolean;
randomSamplingFactor?: number;
repair?: boolean;
}
type Transform<T extends object = object> = {
type: "find";
value: ResultSet.Query<Doc<T>> | string;
} | {
type: "where";
value: ((obj: Doc<T>) => boolean) | string;
} | {
type: "simplesort";
property: keyof T;
options?: boolean | ResultSet.SimpleSortOptions;
} | {
type: "compoundsort";
value: (keyof T | [keyof T, boolean])[];
} | {
type: "sort";
value: (a: Doc<T>, b: Doc<T>) => number;
} | {
type: "sortByScoring";
desc?: boolean;
} | {
type: "limit";
value: number;
} | {
type: "offset";
value: number;
} | {
type: "map";
value: (obj: Doc<T>, index: number, array: Doc<T>[]) => any;
dataOptions?: ResultSet.DataOptions;
} | {
type: "eqJoin";
joinData: Collection<any> | ResultSet<any>;
leftJoinKey: string | ((obj: any) => string);
rightJoinKey: string | ((obj: any) => string);
mapFun?: (left: any, right: any) => any;
dataOptions?: ResultSet.DataOptions;
} | {
type: "mapReduce";
mapFunction: (item: Doc<T>, index: number, array: Doc<T>[]) => any;
reduceFunction: (array: any[]) => any;
} | {
type: "update";
value: (obj: Doc<T>) => any;
} | {
type: "remove";
};
interface TTL {
age: number;
ttlInterval: number;
daemon: any;
}
}
================================================
FILE: dist/packages/fs-storage/types/loki/src/comparators.d.ts
================================================
export interface ILokiComparer<T> {
(a: T, b: T): -1 | 0 | 1;
}
export interface IComparatorMap {
[name: string]: ILokiComparer<any>;
}
/** Map/Register of named ILokiComparer functions returning -1, 0, 1 for lt/eq/gt assertions for two passed parameters */
export declare let ComparatorMap: IComparatorMap;
/** Typescript-friendly factory for strongly typed 'js' comparators */
export declare function CreateJavascriptComparator<T>(): ILokiComparer<T>;
/** Typescript-friendly factory for strongly typed 'abstract js' comparators */
export declare function CreateAbstractJavascriptComparator<T>(): ILokiComparer<T>;
/**
* Comparator which attempts to deal with deal with dates at comparator level.
* Should work for dates in any of the object, string, and number formats
*/
export declare function CreateAbstractDateJavascriptComparator<T>(): ILokiComparer<T>;
/** Typescript-friendly factory for strongly typed 'loki' comparators */
export declare function CreateLokiComparator(): ILokiComparer<any>;
================================================
FILE: dist/packages/fs-storage/types/loki/src/dynamic_view.d.ts
================================================
import { LokiEventEmitter } from "./event_emitter";
import { ResultSet } from "./result_set";
import { Collection } from "./collection";
import { Doc } from "../../common/types";
import { Scorer } from "../../full-text-search/src/scorer";
/**
* DynamicView class is a versatile 'live' view class which can have filters and sorts applied.
* Collection.addDynamicView(name) instantiates this DynamicView object and notifies it
* whenever documents are add/updated/removed so it can remain up-to-date. (chainable)
*
* @example
* let mydv = mycollection.addDynamicView('test'); // default is non-persistent
* mydv.applyFind({ 'doors' : 4 });
* mydv.applyWhere(function(obj) { return obj.name === 'Toyota'; });
* let results = mydv.data();
*
* @extends LokiEventEmitter
* @see {@link Collection#addDynamicView} to construct instances of DynamicView
*
* @param <TData> - the data type
* @param <TNested> - nested properties of data type
*/
export declare class DynamicView<T extends object = object> extends LokiEventEmitter {
readonly name: string;
private _collection;
private _persistent;
private _sortPriority;
private _minRebuildInterval;
private _rebuildPending;
private _resultSet;
private _resultData;
private _resultDirty;
private _cachedResultSet;
private _filterPipeline;
private _sortFunction;
private _sortCriteria;
private _sortCriteriaSimple;
private _sortByScoring;
private _sortDirty;
/**
* Constructor.
* @param {Collection} collection - a reference to the collection to work agains
* @param {string} name - the name of this dynamic view
* @param {object} options - the options
* @param {boolean} [options.persistent=false] - indicates if view is to main internal results array in 'resultdata'
* @param {string} [options.sortPriority="passive"] - the sort priority
* @param {number} [options.minRebuildInterval=1] - minimum rebuild interval (need clarification to docs here)
*/
constructor(collection: Collection<T>, name: string, options?: DynamicView.Options);
/**
* Internally used immediately after deserialization (loading)
* This will clear out and reapply filterPipeline ops, recreating the view.
* Since where filters do not persist correctly, this method allows
* restoring the view to state where user can re-apply those where filters.
*
* @param removeWhereFilters
* @returns {DynamicView} This dynamic view for further chained ops.
* @fires DynamicView.rebuild
*/
private _rematerialize({removeWhereFilters});
/**
* Makes a copy of the internal ResultSet for branched queries.
* Unlike this dynamic view, the branched ResultSet will not be 'live' updated,
* so your branched query should be immediately resolved and not held for future evaluation.
* @param {(string|array=)} transform - Optional name of collection transform, or an array of transform steps
* @param {object} parameters - optional parameters (if optional transform requires them)
* @returns {ResultSet} A copy of the internal ResultSet for branched queries.
*/
branchResultSet(transform?: string | Collection.Transform<T>[], parameters?: object): ResultSet<T>;
/**
* Override of toJSON to avoid circular references.
*/
toJSON(): DynamicView.Serialized;
static fromJSONObject(collection: Collection, obj: DynamicView.Serialized): DynamicView;
/**
* Used to clear pipeline and reset dynamic view to initial state.
* Existing options should be retained.
* @param {boolean} queueSortPhase - (default: false) if true we will async rebuild view (maybe set default to true in future?)
*/
removeFilters({queueSortPhase}?: {
queueSortPhase?: boolean;
}): void;
/**
* Used to apply a sort to the dynamic view
* @example
* dv.applySort(function(obj1, obj2) {
* if (obj1.name === obj2.name) return 0;
* if (obj1.name > obj2.name) return 1;
* if (obj1.name < obj2.name) return -1;
* });
* @param {function} comparefun - a javascript compare function used for sorting
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
applySort(comparefun: (lhs: Doc<T>, rhs: Doc<T>) => number): this;
/**
* Used to specify a property used for view translation.
* @param {string} field - the field name
* @param {boolean|object=} options - boolean for sort descending or options object
* @param {boolean} [options.desc=false] - whether we should sort descending.
* @param {boolean} [options.disableIndexIntersect=false] - whether we should explicity not use array intersection.
* @param {boolean} [options.forceIndexIntersect=false] - force array intersection (if binary index exists).
* @param {boolean} [options.useJavascriptSorting=false] - whether results are sorted via basic javascript sort.
* @returns {DynamicView} this DynamicView object, for further chain ops.
* @example
* dv.applySimpleSort("name");
*/
applySimpleSort(field: keyof T, options?: boolean | ResultSet.SimpleSortOptions): this;
/**
* Allows sorting a ResultSet based on multiple columns.
* @param {Array} criteria - array of property names or subarray of [propertyname, isdesc] used evaluate sort order
* @returns {DynamicView} Reference to this DynamicView, sorted, for future chain operations.
* @example
* // to sort by age and then name (both ascending)
* dv.applySortCriteria(['age', 'name']);
* // to sort by age (ascending) and then by name (descending)
* dv.applySortCriteria(['age', ['name', true]]);
* // to sort by age (descending) and then by name (descending)
* dv.applySortCriteria([['age', true], ['name', true]]);
*/
applySortCriteria(criteria: (keyof T | [keyof T, boolean])[]): this;
/**
* Used to apply a sort by the latest full-text-search scoring.
* @param {boolean} [ascending=false] - sort ascending
*/
applySortByScoring(ascending?: boolean): this;
/**
* Returns the scoring of the last full-text-search.
* @returns {ScoreResult[]}
*/
getScoring(): Scorer.ScoreResult[];
/**
* Marks the beginning of a transaction.
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
startTransaction(): this;
/**
* Commits a transaction.
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
commit(): this;
/**
* Rolls back a transaction.
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
rollback(): this;
/**
* Find the index of a filter in the pipeline, by that filter's ID.
* @param {(string|number)} uid - The unique ID of the filter.
* @returns {number}: index of the referenced filter in the pipeline; -1 if not found.
*/
private _indexOfFilterWithId(uid);
/**
* Add the filter object to the end of view's filter pipeline and apply the filter to the ResultSet.
* @param {object} filter - The filter object. Refer to applyFilter() for extra details.
*/
private _addFilter(filter);
/**
* Reapply all the filters in the current pipeline.
*
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
reapplyFilters(): this;
/**
* Adds or updates a filter in the DynamicView filter pipeline
* @param {object} filter - A filter object to add to the pipeline.
* The object is in the format { 'type': filter_type, 'val', filter_param, 'uid', optional_filter_id }
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
applyFilter(filter: DynamicView.Filter<T>): this;
/**
* applyFind() - Adds or updates a mongo-style query option in the DynamicView filter pipeline
*
* @param {object} query - A mongo-style query object to apply to pipeline
* @param {(string|number)} uid - Optional: The unique ID of this filter, to reference it in the future.
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
applyFind(query: object, uid?: string | number): this;
/**
* Adds or updates a javascript filter function in the DynamicView filter pipeline
* @param {function} fun - A javascript filter function to apply to pipeline
* @param {(string|number)} uid - Optional: The unique ID of this filter, to reference it in the future.
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
applyWhere(fun: (obj: Doc<T>) => boolean, uid?: string | number): this;
/**
* Remove the specified filter from the DynamicView filter pipeline
* @param {(string|number)} uid - The unique ID of the filter to be removed.
* @returns {DynamicView} this DynamicView object, for further chain ops.
*/
removeFilter(uid: string | number): this;
/**
* Returns the number of documents representing the current DynamicView contents.
* @returns {number} The number of documents representing the current DynamicView contents.
*/
count(): number;
/**
* Resolves and pending filtering and sorting, then returns document array as result.
* @param {object} options - optional parameters to pass to ResultSet.data() if non-persistent
* @param {boolean} [options.forceClones] - Allows forcing the return of cloned objects even when
* the collection is not configured for clone object.
* @param {string} [options.forceCloneMethod] - Allows overriding the default or collection specified cloning method.
* Possible values include 'parse-stringify', 'jquery-extend-deep', 'shallow', 'shallow-assign'
* @param {boolean} [options.removeMeta] - will force clones and strip $loki and meta properties from documents
*
* @returns {Array} An array of documents representing the current DynamicView contents.
*/
data(options?: ResultSet.DataOptions): Doc<T>[];
/**
* When the view is not sorted we may still wish to be notified of rebuild events.
* This event will throttle and queue a single rebuild event when batches of updates affect the view.
*/
private _queueRebuildEvent();
/**
* If the view is sorted we will throttle sorting to either :
* (1) passive - when the user calls data(), or
* (2) active - once they stop updating and yield js thread control
*/
private _queueSortPhase();
/**
* Invoked synchronously or asynchronously to perform final sort phase (if needed)
*/
private _performSortPhase(options?);
/**
* (Re)evaluating document inclusion.
* Called by : collection.insert() and collection.update().
* @param {int} objIndex - index of document to (re)run through filter pipeline.
* @param {boolean} isNew - true if the document was just added to the collection.
* @hidden
*/
_evaluateDocument(objIndex: number, isNew: boolean): void;
/**
* Internal function called on collection.delete().
* @hidden
*/
_removeDocument(objIndex: number): void;
/**
* Data transformation via user supplied functions
* @param {function} mapFunction - this function accepts a single document for you to transform and return
* @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value
* @returns The output of your reduceFunction
*/
mapReduce<U1, U2>(mapFunction: (item: T, index: number, array: T[]) => U1, reduceFunction: (array: U1[]) => U2): U2;
}
export declare namespace DynamicView {
interface Options {
persistent?: boolean;
sortPriority?: SortPriority;
minRebuildInterval?: number;
}
type SortPriority = "passive" | "active";
interface Serialized {
name: string;
_persistent: boolean;
_sortPriority: SortPriority;
_minRebuildInterval: number;
_resultSet: ResultSet<any>;
_filterPipeline: Filter<any>[];
_sortCriteria: (string | [string, boolean])[];
_sortCriteriaSimple: {
field: string;
options: boolean | ResultSet.SimpleSortOptions;
};
_sortByScoring: boolean;
_sortDirty: boolean;
}
type Filter<T extends object = object> = {
type: "find";
val: ResultSet.Query<Doc<T>>;
uid: number | string;
} | {
type: "where";
val: (obj: Doc<T>) => boolean;
uid: number | string;
};
}
================================================
FILE: dist/packages/fs-storage/types/loki/src/event_emitter.d.ts
================================================
/**
* LokiEventEmitter is a minimalist version of EventEmitter. It enables any
* constructor that inherits EventEmitter to emit events and trigger
* listeners that have been added to the event through the on(event, callback) method
*
* @constructor LokiEventEmitter
*/
export declare class LokiEventEmitter {
/**
* A map, with each property being an array of callbacks.
*/
protected _events: object;
/**
* Determines whether or not the callbacks associated with each event should happen in an async fashion or not.
* Default is false, which means events are synchronous
*/
protected _asyncListeners: boolean;
/**
* Adds a listener to the queue of callbacks associated to an event
* @param {string|string[]} eventName - the name(s) of the event(s) to listen to
* @param {function} listener - callback function of listener to attach
* @returns {int} the index of the callback in the array of listeners for a particular event
*/
on(eventName: string | string[], listener: Function): Function;
/**
* Emits a particular event
* with the option of passing optional parameters which are going to be processed by the callback
* provided signatures match (i.e. if passing emit(event, arg0, arg1) the listener should take two parameters)
* @param {string} eventName - the name of the event
* @param {object} data - optional object passed with the event
*/
protected emit(eventName: string, ...data: any[]): void;
/**
* Alias of EventEmitter.on().
*/
addListener(eventName: string | string[], listener: Function): Function;
/**
* Removes the listener at position 'index' from the event 'eventName'
* @param {string|string[]} eventName - the name(s) of the event(s) which the listener is attached to
* @param {function} listener - the listener callback function to remove from emitter
*/
removeListener(eventName: string | string[], listener: Function): void;
}
================================================
FILE: dist/packages/fs-storage/types/loki/src/index.d.ts
================================================
import { Loki } from "./loki";
import { Collection } from "./collection";
export { Loki, Collection };
export default Loki;
================================================
FILE: dist/packages/fs-storage/types/loki/src/loki.d.ts
================================================
import { LokiEventEmitter } from "./event_emitter";
import { Collection } from "./collection";
import { Doc, StorageAdapter } from "../../common/types";
import { IComparatorMap } from "./comparators";
import { IRangedIndexFactoryMap } from "./ranged_indexes";
import { ILokiOperatorPackageMap } from "./operator_packages";
export declare class Loki extends LokiEventEmitter {
filename: string;
private databaseVersion;
private engineVersion;
_collections: Collection[];
private _env;
private _serializationMethod;
private _destructureDelimiter;
private _persistenceMethod;
private _persistenceAdapter;
private _throttledSaves;
private _throttledSaveRunning;
private _throttledSavePending;
private _autosave;
private _autosaveInterval;
private _autosaveRunning;
private _autosaveHandler;
/**
* Constructs the main database class.
* @param {string} filename - name of the file to be saved to
* @param {object} [options={}] - options
* @param {Loki.Environment} [options.env] - the javascript environment
* @param {Loki.SerializationMethod} [options.serializationMethod=NORMAL] - the serialization method
* @param {string} [options.destructureDelimiter="$<\n"] - string delimiter used for destructured serialization
* @param {IComparatorMap} [options.comparatorMap] allows injecting or overriding registered comparators
* @param {IRangedIndexFactoryMap} [options.rangedIndexFactoryMap] allows injecting or overriding registered ranged index factories
* @param {ILokiOperatorPackageMap} [options.lokiOperatorPackageMap] allows injecting or overriding registered loki operator packages
*/
constructor(filename?: string, options?: Loki.Options);
/**
* configures options related to database persistence.
*
* @param {Loki.PersistenceOptions} [options={}] - options
* @param {adapter} [options.adapter=auto] - an instance of a loki persistence adapter
* @param {boolean} [options.autosave=false] - enables autosave
* @param {int} [options.autosaveInterval=5000] - time interval (in milliseconds) between saves (if dirty)
* @param {boolean} [options.autoload=false] - enables autoload on loki instantiation
* @param {object} options.inflate - options that are passed to loadDatabase if autoload enabled
* @param {boolean} [options.throttledSaves=true] - if true, it batches multiple calls to to saveDatabase reducing number of
* disk I/O operations and guaranteeing proper serialization of the calls. Default value is true.
* @param {Loki.PersistenceMethod} options.persistenceMethod - a persistence method which should be used (FS_STORAGE, LOCAL_STORAGE...)
* @returns {Promise} a Promise that resolves after initialization and (if enabled) autoloading the database
*/
initializePersistence(options?: Loki.PersistenceOptions): Promise<void>;
/**
* Copies 'this' database into a new Loki instance. Object references are shared to make lightweight.
* @param {object} options - options
* @param {boolean} options.removeNonSerializable - nulls properties not safe for serialization.
*/
copy(options?: Loki.CopyOptions): Loki;
/**
* Adds a collection to the database.
* @param {string} name - name of collection to add
* @param {object} [options={}] - options to configure collection with.
* @param {array} [options.unique=[]] - array of property names to define unique constraints for
* @param {array} [options.exact=[]] - array of property names to define exact constraints for
* @param {array} [options.indices=[]] - array property names to define binary indexes for
* @param {boolean} [options.asyncListeners=false] - whether listeners are called asynchronously
* @param {boolean} [options.disableMeta=false] - set to true to disable meta property on documents
* @param {boolean} [options.disableChangesApi=true] - set to false to enable Changes Api
* @param {boolean} [options.disableDeltaChangesApi=true] - set to false to enable Delta Changes API (requires Changes API, forces cloning)
* @param {boolean} [options.clone=false] - specify whether inserts and queries clone to/from user
* @param {string} [options.cloneMethod=CloneMethod.DEEP] - the clone method
* @param {number} [options.ttl=] - age of document (in ms.) before document is considered aged/stale
* @param {number} [options.ttlInterval=] - time interval for clearing out 'aged' documents; not set by default
* @returns {Collection} a reference to the collection which was just added
*/
addCollection<TData extends object = object, TNested extends object = object>(name: string, options?: Collection.Options<TData, TNested>): Collection<TData, TNested>;
loadCollection(collection: Collection): void;
/**
* Retrieves reference to a collection by name.
* @param {string} name - name of collection to look up
* @returns {Collection} Reference to collection in database by that name, or null if not found
*/
getCollection<TData extends object = object, TNested extends object = object>(name: string): Collection<TData, TNested>;
/**
* Renames an existing loki collection
* @param {string} oldName - name of collection to rename
* @param {string} newName - new name of collection
* @returns {Collection} reference to the newly renamed collection
*/
renameCollection<TData extends object = object, TNested extends object = object>(oldName: string, newName: string): Collection<TData, TNested>;
listCollections(): {
name: string;
count: number;
}[];
/**
* Removes a collection from the database.
* @param {string} collectionName - name of collection to remove
*/
removeCollection(collectionName: string): void;
/**
* Serialize database to a string which can be loaded via {@link Loki#loadJSON}
*
* @returns {string} Stringified representation of the loki database.
*/
serialize(options?: Loki.SerializeOptions): string | string[];
toJSON(): Loki.Serialized;
/**
* Database level destructured JSON serialization routine to allow alternate serialization methods.
* Internally, Loki supports destructuring via loki "serializationMethod' option and
* the optional LokiPartitioningAdapter class. It is also available if you wish to do
* your own structured persistence or data exchange.
*
* @param {object} options - output format options for use externally to loki
* @param {boolean} [options.partitioned=false] - whether db and each collection are separate
* @param {int} options.partition - can be used to only output an individual collection or db (-1)
* @param {boolean} [options.delimited=true] - whether subitems are delimited or subarrays
* @param {string} options.delimiter - override default delimiter
*
* @returns {string|Array} A custom, restructured aggregation of independent serializations.
*/
serializeDestructured(options?: Loki.SerializeDestructuredOptions): string | string[];
/**
* Collection level utility method to serialize a collection in a 'destructured' format
*
* @param {object} options - used to determine output of method
* @param {int} options.delimited - whether to return single delimited string or an array
* @param {string} options.delimiter - (optional) if delimited, this is delimiter to use
* @param {int} options.collectionIndex - specify which collection to serialize data for
*
* @returns {string|array} A custom, restructured aggregation of independent serializations for a single collection.
*/
serializeCollection(options?: {
delimited?: boolean;
collectionIndex?: number;
delimiter?: string;
}): string | string[];
/**
* Database level destructured JSON deserialization routine to minimize memory overhead.
* Internally, Loki supports destructuring via loki "serializationMethod' option and
* the optional LokiPartitioningAdapter class. It is also available if you wish to do
* your own structured persistence or data exchange.
*
* @param {string|array} destructuredSource - destructured json or array to deserialize from
* @param {object} options - source format options
* @param {boolean} [options.partitioned=false] - whether db and each collection are separate
* @param {int} options.partition - can be used to deserialize only a single partition
* @param {boolean} [options.delimited=true] - whether subitems are delimited or subarrays
* @param {string} options.delimiter - override default delimiter
*
* @returns {object|array} An object representation of the deserialized database, not yet applied to 'this' db or document array
*/
deserializeDestructured(destructuredSource: string | string[], options?: Loki.SerializeDestructuredOptions): any;
/**
* Collection level utility function to deserializes a destructured collection.
*
* @param {string|string[]} destructuredSource - destructured representation of collection to inflate
* @param {object} options - used to describe format of destructuredSource input
* @param {int} [options.delimited=false] - whether source is delimited string or an array
* @param {string} options.delimiter - if delimited, this is delimiter to use (if other than default)
*
* @returns {Array} an array of documents to attach to collection.data.
*/
deserializeCollection<T extends object = object>(destructuredSource: string | string[], options?: Loki.DeserializeCollectionOptions): Doc<T>[];
/**
* Inflates a loki database from a serialized JSON string
*
* @param {string} serializedDb - a serialized loki database string
* @param {object} options - apply or override collection level settings
* @param {boolean} options.retainDirtyFlags - whether collection dirty flags will be preserved
*/
loadJSON(serializedDb: string | string[], options?: Collection.DeserializeOptions): void;
/**
* Inflates a loki database from a JS object
*
* @param {object} dbObject - a serialized loki database object
* @param {object} options - apply or override collection level settings
* @param {boolean} options.retainDirtyFlags - whether collection dirty flags will be preserved
*/
loadJSONObject(dbObject: Loki, options?: Collection.DeserializeOptions): void;
loadJSONObject(dbObject: Loki.Serialized, options?: Collection.DeserializeOptions): void;
/**
* Emits the close event. In autosave scenarios, if the database is dirty, this will save and disable timer.
* Does not actually destroy the db.
*
* @returns {Promise} a Promise that resolves after closing the database succeeded
*/
close(): Promise<void>;
/**-------------------------+
| Changes API |
+--------------------------*/
/**
* The Changes API enables the tracking the changes occurred in the collections since the beginning of the session,
* so it's possible to create a differential dataset for synchronization purposes (possibly to a remote db)
*/
/**
* (Changes API) : takes all the changes stored in each
* collection and creates a single array for the entire database. If an array of names
* of collections is passed then only the included collections will be tracked.
*
* @param {Array} [arrayOfCollectionNames=] - array of collection names. No arg means all collections are processed.
* @returns {Array} array of changes
* @see private method _createChange() in Collection
*/
generateChangesNotification(arrayOfCollectionNames?: string[]): Collection.Change[];
/**
* (Changes API) - stringify changes for network transmission
* @returns {string} string representation of the changes
*/
serializeChanges(collectionNamesArray?: string[]): string;
/**
* (Changes API) : clears all the changes in all collections.
*/
clearChanges(): void;
/**
* Wait for throttledSaves to complete and invoke your callback when drained or duration is met.
*
* @param {object} options - configuration options
* @param {boolean} [options.recursiveWait=true] - if after queue is drained, another save was kicked off, wait for it
* @param {boolean} [options.recursiveWaitLimit=false] - limit our recursive waiting to a duration
* @param {number} [options.recursiveWaitLimitDuration=2000] - cutoff in ms to stop recursively re-draining
* @param {Date} [options.started=now()] - the start time of the recursive wait duration
* @returns {Promise} a Promise that resolves when save queue is drained, it is passed a sucess parameter value
*/
throttledSaveDrain(options?: Loki.ThrottledDrainOptions): Promise<void>;
/**
* Internal load logic, decoupled from throttling/contention logic
*
* @param {object} options - an object containing inflation options for each collection
* @param {boolean} ignore_not_found - does not raise an error if database is not found
* @returns {Promise} a Promise that resolves after the database is loaded
*/
private _loadDatabase(options?, ignore_not_found?);
/**
* Handles manually loading from an adapter storage (such as fs-storage)
* This method utilizes loki configuration options (if provided) to determine which
* persistence method to use, or environment detection (if configuration was not provided).
* To avoid contention with any throttledSaves, we will drain the save queue first.
*
* If you are configured with autosave, you do not need to call this method yourself.
*
* @param {object} [options={}] - if throttling saves and loads, this controls how we drain save queue before loading
* @param {boolean} [options.recursiveWait=true] wait recursively until no saves are queued
* @param {boolean} [options.recursiveWaitLimit=false] limit our recursive waiting to a duration
* @param {number} [options.recursiveWaitLimitDelay=2000] cutoff in ms to stop recursively re-draining
* @param {Date} [options.started=now()] - the start time of the recursive wait duration
* @returns {Promise} a Promise that resolves after the database is loaded
*/
loadDatabase(options?: Loki.LoadDatabaseOptions): Promise<void>;
private _saveDatabase();
/**
* Handles manually saving to an adapter storage (such as fs-storage)
* This method utilizes loki configuration options (if provided) to determine which
* persistence method to use, or environment detection (if configuration was not provided).
*
* If you are configured with autosave, you do not need to call this method yourself.
*
* @returns {Promise} a Promise that resolves after the database is persisted
*/
saveDatabase(): Promise<void>;
/**
* Handles deleting a database from the underlying storage adapter
*
* @returns {Promise} a Promise that resolves after the database is deleted
*/
deleteDatabase(): Promise<void>;
/****************
* Autosave API
****************/
/**
* Check whether any collections are "dirty" meaning we need to save the (entire) database
* @returns {boolean} - true if database has changed since last autosave, otherwise false
*/
private _autosaveDirty();
/**
* Resets dirty flags on all collections.
*/
private _autosaveClearFlags();
/**
* Starts periodically saves to the underlying storage adapter.
*/
private _autosaveEnable();
/**
* Stops the autosave interval timer.
*/
private _autosaveDisable();
}
export declare namespace Loki {
interface Options {
env?: Environment;
serializationMethod?: SerializationMethod;
destructureDelimiter?: string;
comparatorMap?: IComparatorMap;
rangedIndexFactoryMap?: IRangedIndexFactoryMap;
lokiOperatorPackageMap?: ILokiOperatorPackageMap;
}
interface PersistenceOptions {
adapter?: StorageAdapter;
autosave?: boolean;
autosaveInterval?: number;
autoload?: boolean;
throttledSaves?: boolean;
persistenceMethod?: Loki.PersistenceMethod;
inflate?: any;
}
interface CopyOptions {
removeNonSerializable?: boolean;
}
interface SerializeOptions {
serializationMethod?: SerializationMethod;
}
interface SerializeDestructuredOptions {
partitioned?: boolean;
partition?: number;
delimited?: boolean;
delimiter?: string;
}
interface DeserializeCollectionOptions {
partitioned?: boolean;
delimited?: boolean;
delimiter?: string;
}
interface ThrottledDrainOptions {
recursiveWait?: boolean;
recursiveWaitLimit?: boolean;
recursiveWaitLimitDuration?: number;
started?: Date;
}
interface Serialized {
_env: Environment;
_serializationMethod: SerializationMethod;
_autosave: boolean;
_autosaveInterval: number;
_collections: Collection[];
databaseVersion: number;
engineVersion: number;
filename: string;
_persistenceAdapter: StorageAdapter;
_persistenceMethod: PersistenceMethod;
_throttledSaves: boolean;
}
type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrainOptions;
type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-storage" | "memory-storage" | "adapter";
type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "MEMORY";
}
================================================
FILE: dist/packages/fs-storage/types/loki/src/operator_packages.d.ts
================================================
import { ILokiComparer } from "./comparators";
/** Hash interface for named LokiOperatorPackage registration */
export interface ILokiOperatorPackageMap {
[name: string]: LokiOperatorPackage;
}
/**
* Helper function for determining 'loki' abstract equality which is a little more abstract than ==
* aeqHelper(5, '5') === true
* aeqHelper(5.0, '5') === true
* aeqHelper(new Date("1/1/2011"), new Date("1/1/2011")) === true
* aeqHelper({a:1}, {z:4}) === true (all objects sorted equally)
* aeqHelper([1, 2, 3], [1, 3]) === false
* aeqHelper([1, 2, 3], [1, 2, 3]) === true
* aeqHelper(undefined, null) === true
* @param {any} prop1
* @param {any} prop2
* @returns {boolean}
* @hidden
*/
export declare function aeqHelper(prop1: any, prop2: any): boolean;
/**
* Helper function for determining 'less-than' conditions for ops, sorting, and binary indices.
* In the future we might want $lt and $gt ops to use their own functionality/helper.
* Since binary indices on a property might need to index [12, NaN, new Date(), Infinity], we
* need this function (as well as gtHelper) to always ensure one value is LT, GT, or EQ to another.
* @hidden
*/
export declare function ltHelper(prop1: any, prop2: any, equal: boolean): boolean;
/**
* @hidden
* @param {any} prop1
* @param {any} prop2
* @param {boolean} equal
* @returns {boolean}
*/
export declare function gtHelper(prop1: any, prop2: any, equal: boolean): boolean;
/**
* @param {any} prop1
* @param {any} prop2
* @param {boolean} descending
* @returns {number}
* @hidden
*/
export declare function sortHelper(prop1: any, prop2: any, descending: boolean): number;
/**
* Default implementation of LokiOperatorPackage, using fastest javascript comparison operators.
*/
export declare class LokiOperatorPackage {
$eq(a: any, b: any): boolean;
$ne(a: any, b: any): boolean;
$gt(a: any, b: any): boolean;
$gte(a: any, b: any): boolean;
$lt(a: any, b: any): boolean;
$lte(a: any, b: any): boolean;
$between(a: any, range: [any, any]): boolean;
$in(a: any, b: any): boolean;
$nin(a: any, b: any): boolean;
$keyin(a: string, b: object): boolean;
$nkeyin(a: string, b: object): boolean;
$definedin(a: string, b: object): boolean;
$undefinedin(a: string, b: object): boolean;
$regex(a: string, b: RegExp): boolean;
$containsNone(a: any, b: any): boolean;
$containsAny(a: any, b: any): boolean;
$contains(a: any, b: any): boolean;
$type(a: any, b: any): boolean;
$finite(a: number, b: boolean): boolean;
$size(a: any, b: any): boolean;
$len(a: any, b: any): boolean;
$where(a: any, b: any): boolean;
$not(a: any, b: any): boolean;
$and(a: any, b: any): boolean;
$or(a: any, b: any): boolean;
private doQueryOp(val, op);
private containsCheckFn(a);
}
/**
* LokiOperatorPackage which utilizes abstract 'loki' comparisons for basic relational equality op implementations.
*/
export declare class LokiAbstractOperatorPackage extends LokiOperatorPackage {
constructor();
$eq(a: any, b: any): boolean;
$ne(a: any, b: any): boolean;
$gt(a: any, b: any): boolean;
$gte(a: any, b: any): boolean;
$lt(a: any, b: any): boolean;
$lte(a: any, b: any): boolean;
$between(a: any, range: [any, any]): boolean;
}
/**
* LokiOperatorPackage which utilizes provided comparator for basic relational equality op implementations.
*/
export declare class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
comparator: ILokiComparer<T>;
constructor(comparator: ILokiComparer<T>);
$eq(a: any, b: any): boolean;
$ne(a: any, b: any): boolean;
$gt(a: any, b: any): boolean;
$gte(a: any, b: any): boolean;
$lt(a: any, b: any): boolean;
$lte(a: any, b: any): boolean;
$between(a: any, range: [any, any]): boolean;
}
/**
* Map/Register of named LokiOperatorPackages which implement all unindexed query ops within 'find' query objects
*/
export declare let LokiOperatorPackageMap: ILokiOperatorPackageMap;
================================================
FILE: dist/packages/fs-storage/types/loki/src/ranged_indexes.d.ts
================================================
import { ILokiComparer } from "./comparators";
export declare type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$neq" | "$between";
export interface IRangedIndexRequest<T> {
op: RangedValueOperator;
val: T;
high?: T;
}
/** Defines interface which all loki ranged indexes need to implement */
export interface IRangedIndex<T> {
insert(id: number, val: T): void;
update(id: number, val: T): void;
remove(id: number): void;
restore(tree: any): void;
backup(): IRangedIndex<T>;
rangeRequest(range?: IRangedIndexRequest<T>): number[];
validateIndex(): boolean;
}
/** Hash Interface for global ranged index factory map*/
export interface IRangedIndexFactoryMap {
[name: string]: (name: string, comparator: ILokiComparer<any>) => IRangedIndex<any>;
}
/** Map/Register of named factory functions returning IRangedIndex instances */
export declare let RangedIndexFactoryMap: IRangedIndexFactoryMap;
================================================
FILE: dist/packages/fs-storage/types/loki/src/result_set.d.ts
================================================
import { Collection } from "./collection";
import { CloneMethod } from "./clone";
import { Doc } from "../../common/types";
import { Scorer } from "../../full-text-search/src/scorer";
import { Query as FullTextSearchQuery } from "../../full-text-search/src/query_types";
/**
* ResultSet class allowing chainable queries. Intended to be instanced internally.
* Collection.find(), Collection.where(), and Collection.chain() instantiate this.
*
* @example
* mycollection.chain()
* .find({ 'doors' : 4 })
* .where(function(obj) { return obj.name === 'Toyota' })
* .data();
*
* @param <TData> - the data type
* @param <TNested> - nested properties of data type
*/
export declare class ResultSet<T extends object = object> {
_collection: Collection<T>;
_filteredRows: number[];
_filterInitialized: boolean;
private _scoring;
/**
* Constructor.
* @param {Collection} collection - the collection which this ResultSet will query against
*/
constructor(collection: Collection<T>);
/**
* Reset the ResultSet to its initial state.
* @returns {ResultSet} Reference to this ResultSet, for future chain operations.
*/
reset(): this;
/**
* Override of toJSON to avoid circular references
*/
toJSON(): ResultSet<T>;
/**
* Allows you to limit the number of documents passed to next chain operation.
* A ResultSet copy() is made to avoid altering original ResultSet.
* @param {int} qty - The number of documents to return.
* @returns {ResultSet} Returns a copy of the ResultSet, limited by qty, for subsequent chain ops.
*/
limit(qty: number): this;
/**
* Used for skipping 'pos' number of documents in the ResultSet.
* @param {int} pos - Number of documents to skip; all preceding documents are filtered out.
* @returns {ResultSet} Returns a copy of the ResultSet, containing docs starting at 'pos' for subsequent chain ops.
*/
offset(pos: number): this;
/**
* To support reuse of ResultSet in branched query situations.
* @returns {ResultSet} Returns a copy of the ResultSet (set) but the underlying document references will be the same.
*/
copy(): ResultSet<T>;
/**
* Executes a named collection transform or raw array of transform steps against the ResultSet.
* @param {(string|array)} transform - name of collection transform or raw transform array
* @param {object} [parameters=] - object property hash of parameters, if the transform requires them.
* @returns {ResultSet} either (this) ResultSet or a clone of of this ResultSet (depending on steps)
*/
transform(transform: string | Collection.Transform<T>[], parameters?: object): this;
/**
* User supplied compare function is provided two documents to compare. (chainable)
* @example
* rslt.sort(function(obj1, obj2) {
* if (obj1.name === obj2.name) return 0;
* if (obj1.name > obj2.name) return 1;
* if (obj1.name < obj2.name) return -1;
* });
* @param {function} comparefun - A javascript compare function used for sorting.
* @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.
*/
sort(comparefun: (a: Doc<T>, b: Doc<T>) => number): this;
/**
* Simpler, loose evaluation for user to sort based on a property name. (chainable).
* Sorting based on the same lt/gt helper functions used for binary indices.
* @param {string} propname - name of property to sort by.
* @param {boolean|object=} options - boolean for sort descending or options object
* @param {boolean} [options.desc=false] - whether to sort descending
* @param {string} [options.sortComparator] override default with name of comparator registered in ComparatorMap
* @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.
*/
simplesort(propname: keyof T, options?: boolean | ResultSet.SimpleSortOptions): this;
/**
* Allows sorting a ResultSet based on multiple columns.
* @example
* // to sort by age and then name (both ascending)
* rs.compoundsort(['age', 'name']);
* // to sort by age (ascending) and then by name (descending)
* rs.compoundsort(['age', ['name', true]);
* @param {array} properties - array of property names or subarray of [propertyname, isdesc] used evaluate sort order
* @returns {ResultSet} Reference to this ResultSet, sorted, for future chain operations.
*/
compoundsort(properties: (keyof T | [keyof T, boolean])[]): this;
/**
* Helper function for compoundsort(), performing individual object comparisons
* @param {Array} properties - array of property names, in order, by which to evaluate sort order
* @param {object} obj1 - first object to compare
* @param {object} obj2 - second object to compare
* @returns {number} 0, -1, or 1 to designate if identical (sortwise) or which should be first
*/
private _compoundeval(properties, obj1, obj2);
/**
* Sorts the ResultSet based on the last full-text-search scoring.
* @param {boolean} [ascending=false] - sort ascending
* @returns {ResultSet}
*/
sortByScoring(ascending?: boolean): this;
/**
* Returns the scoring of the last full-text-search.
* @returns {ScoreResult[]}
*/
getScoring(): Scorer.ScoreResult[];
/**
* Oversee the operation of OR'ed query expressions.
* OR'ed expression evaluation runs each expression individually against the full collection,
* and finally does a s
gitextract_bumayf7k/ ├── .editorconfig ├── .github/ │ ├── ISSUE_TEMPLATE.md │ └── PULL_REQUEST_TEMPLATE.md ├── .gitignore ├── .travis.yml ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── DEVELOPER.md ├── LICENSE ├── README.md ├── benchmark/ │ ├── benchmark.js │ └── benchmark_indexes.js ├── config/ │ ├── jasmine.json │ ├── karma.config.js │ ├── nycrc.json │ ├── nycrc.node.json │ ├── tsconfig.tslint.json │ ├── tsconfig.webpack.json │ ├── tslint.json │ └── webpack-config-creator.js ├── dist/ │ └── packages/ │ ├── fs-storage/ │ │ ├── lokidb.fs-storage.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── full-text-search/ │ │ ├── lokidb.full-text-search.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── full-text-search-language/ │ │ ├── lokidb.full-text-search-language.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── full-text-search-language-de/ │ │ ├── lokidb.full-text-search-language-de.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── full-text-search-language-en/ │ │ ├── lokidb.full-text-search-language-en.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── indexed-storage/ │ │ ├── lokidb.indexed-storage.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── local-storage/ │ │ ├── lokidb.local-storage.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── loki/ │ │ ├── lokidb.loki.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ ├── memory-storage/ │ │ ├── lokidb.memory-storage.js │ │ └── types/ │ │ ├── common/ │ │ │ ├── plugin.d.ts │ │ │ └── types.d.ts │ │ ├── fs-storage/ │ │ │ └── src/ │ │ │ ├── fs_storage.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search/ │ │ │ └── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.d.ts │ │ │ │ ├── character_filter.d.ts │ │ │ │ ├── token_filter.d.ts │ │ │ │ └── tokenizer.d.ts │ │ │ ├── full_text_search.d.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.d.ts │ │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ │ ├── levenshtein_automata.d.ts │ │ │ │ ├── long.d.ts │ │ │ │ ├── parametric_description.d.ts │ │ │ │ └── run_automaton.d.ts │ │ │ ├── index.d.ts │ │ │ ├── index_searcher.d.ts │ │ │ ├── inverted_index.d.ts │ │ │ ├── query_types.d.ts │ │ │ └── scorer.d.ts │ │ ├── full-text-search-language/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── language.d.ts │ │ ├── full-text-search-language-de/ │ │ │ └── src/ │ │ │ ├── german_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── full-text-search-language-en/ │ │ │ └── src/ │ │ │ ├── english_analyzer.d.ts │ │ │ └── index.d.ts │ │ ├── indexed-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── indexed_storage.d.ts │ │ ├── local-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── local_storage.d.ts │ │ ├── loki/ │ │ │ └── src/ │ │ │ ├── avl_index.d.ts │ │ │ ├── clone.d.ts │ │ │ ├── collection.d.ts │ │ │ ├── comparators.d.ts │ │ │ ├── dynamic_view.d.ts │ │ │ ├── event_emitter.d.ts │ │ │ ├── index.d.ts │ │ │ ├── loki.d.ts │ │ │ ├── operator_packages.d.ts │ │ │ ├── ranged_indexes.d.ts │ │ │ ├── result_set.d.ts │ │ │ └── unique_index.d.ts │ │ ├── memory-storage/ │ │ │ └── src/ │ │ │ ├── index.d.ts │ │ │ └── memory_storage.d.ts │ │ └── partitioning-adapter/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── partitioning_adapter.d.ts │ └── partitioning-adapter/ │ ├── lokidb.partitioning-adapter.js │ └── types/ │ ├── common/ │ │ ├── plugin.d.ts │ │ └── types.d.ts │ ├── fs-storage/ │ │ └── src/ │ │ ├── fs_storage.d.ts │ │ └── index.d.ts │ ├── full-text-search/ │ │ └── src/ │ │ ├── analyzer/ │ │ │ ├── analyzer.d.ts │ │ │ ├── character_filter.d.ts │ │ │ ├── token_filter.d.ts │ │ │ └── tokenizer.d.ts │ │ ├── full_text_search.d.ts │ │ ├── fuzzy/ │ │ │ ├── automaton.d.ts │ │ │ ├── lev1t_parametric_description.d.ts │ │ │ ├── lev2t_parametric_description.d.ts │ │ │ ├── levenshtein_automata.d.ts │ │ │ ├── long.d.ts │ │ │ ├── parametric_description.d.ts │ │ │ └── run_automaton.d.ts │ │ ├── index.d.ts │ │ ├── index_searcher.d.ts │ │ ├── inverted_index.d.ts │ │ ├── query_types.d.ts │ │ └── scorer.d.ts │ ├── full-text-search-language/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── language.d.ts │ ├── full-text-search-language-de/ │ │ └── src/ │ │ ├── german_analyzer.d.ts │ │ └── index.d.ts │ ├── full-text-search-language-en/ │ │ └── src/ │ │ ├── english_analyzer.d.ts │ │ └── index.d.ts │ ├── indexed-storage/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── indexed_storage.d.ts │ ├── local-storage/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── local_storage.d.ts │ ├── loki/ │ │ └── src/ │ │ ├── avl_index.d.ts │ │ ├── clone.d.ts │ │ ├── collection.d.ts │ │ ├── comparators.d.ts │ │ ├── dynamic_view.d.ts │ │ ├── event_emitter.d.ts │ │ ├── index.d.ts │ │ ├── loki.d.ts │ │ ├── operator_packages.d.ts │ │ ├── ranged_indexes.d.ts │ │ ├── result_set.d.ts │ │ └── unique_index.d.ts │ ├── memory-storage/ │ │ └── src/ │ │ ├── index.d.ts │ │ └── memory_storage.d.ts │ └── partitioning-adapter/ │ └── src/ │ ├── index.d.ts │ └── partitioning_adapter.d.ts ├── docs/ │ ├── comparators.md │ ├── css/ │ │ ├── codemirror/ │ │ │ ├── codemirror.css │ │ │ └── foldgutter.css │ │ └── javascript_editor.css │ ├── index.md │ ├── js/ │ │ ├── codemirror/ │ │ │ ├── addon/ │ │ │ │ ├── edit/ │ │ │ │ │ └── matchbrackets.js │ │ │ │ └── fold/ │ │ │ │ ├── brace-fold.js │ │ │ │ ├── foldcode.js │ │ │ │ └── foldgutter.js │ │ │ ├── lib/ │ │ │ │ └── codemirror.js │ │ │ └── mode/ │ │ │ └── javascript/ │ │ │ └── javascript.js │ │ ├── gitter.js │ │ └── javascript_editor.js │ ├── operator_packages.md │ └── ranged_indexes.md ├── integration/ │ ├── .gitignore │ ├── config/ │ │ ├── jasmine.json │ │ ├── karma.amd.config.js │ │ └── karma.browser.config.js │ ├── package.json │ ├── scripts/ │ │ └── install_lokidb.ts │ └── spec/ │ ├── generic/ │ │ ├── full-text-search-language-de.spec.js │ │ ├── full-text-search-language-en.spec.js │ │ ├── full-text-search-language.spec.js │ │ ├── full-text-search.spec.js │ │ ├── loki.spec.js │ │ ├── memory-storage.spec.js │ │ └── partitioning-adapter.spec.js │ ├── helper/ │ │ └── integration.helper.js │ ├── node/ │ │ └── node-storage.spec.js │ └── web/ │ ├── indexed-storage.spec.js │ └── local-storage.spec.js ├── mkdocs.yml ├── package.json ├── packages/ │ ├── common/ │ │ ├── plugin.ts │ │ └── types.ts │ ├── fs-storage/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── node/ │ │ │ └── fs_storage.spec.ts │ │ ├── src/ │ │ │ ├── fs_storage.ts │ │ │ └── index.ts │ │ └── webpack.config.js │ ├── full-text-search/ │ │ ├── package.json │ │ ├── spec/ │ │ │ ├── generic/ │ │ │ │ ├── analyzer/ │ │ │ │ │ ├── character_filter.spec.ts │ │ │ │ │ ├── token_filter.spec.ts │ │ │ │ │ └── tokenizer.spec.ts │ │ │ │ ├── full_text_search.spec.ts │ │ │ │ ├── inverted_index.spec.ts │ │ │ │ └── search/ │ │ │ │ ├── fuzzy.spec.ts │ │ │ │ └── wildcard.spec.ts │ │ │ └── node/ │ │ │ ├── MOCK_DATA.ts │ │ │ ├── QUERIES.ts │ │ │ └── elasticsearch.spec.ts │ │ ├── src/ │ │ │ ├── analyzer/ │ │ │ │ ├── analyzer.ts │ │ │ │ ├── character_filter.ts │ │ │ │ ├── token_filter.ts │ │ │ │ └── tokenizer.ts │ │ │ ├── full_text_search.ts │ │ │ ├── fuzzy/ │ │ │ │ ├── automaton.ts │ │ │ │ ├── lev1t_parametric_description.ts │ │ │ │ ├── lev2t_parametric_description.ts │ │ │ │ ├── levenshtein_automata.ts │ │ │ │ ├── long.ts │ │ │ │ ├── parametric_description.ts │ │ │ │ └── run_automaton.ts │ │ │ ├── index.ts │ │ │ ├── index_searcher.ts │ │ │ ├── inverted_index.ts │ │ │ ├── query_types.ts │ │ │ └── scorer.ts │ │ └── webpack.config.js │ ├── full-text-search-language/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── helper/ │ │ │ └── create_lanuage_test.helper.ts │ │ ├── src/ │ │ │ ├── index.ts │ │ │ └── language.ts │ │ └── webpack.config.js │ ├── full-text-search-language-de/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── generic/ │ │ │ └── german_analyzer.spec.ts │ │ ├── src/ │ │ │ ├── german_analyzer.ts │ │ │ └── index.ts │ │ └── webpack.config.js │ ├── full-text-search-language-en/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── generic/ │ │ │ └── english_analyzer.spec.ts │ │ ├── src/ │ │ │ ├── english_analyzer.ts │ │ │ └── index.ts │ │ └── webpack.config.js │ ├── indexed-storage/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── web/ │ │ │ └── indexed_storage.spec.ts │ │ ├── src/ │ │ │ ├── index.ts │ │ │ └── indexed_storage.ts │ │ └── webpack.config.js │ ├── local-storage/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── web/ │ │ │ └── local_storage.spec.ts │ │ ├── src/ │ │ │ ├── index.ts │ │ │ └── local_storage.ts │ │ └── webpack.config.js │ ├── loki/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── generic/ │ │ │ ├── avl-index.spec.ts │ │ │ ├── changesApi.spec.ts │ │ │ ├── cloning.spec.ts │ │ │ ├── collection.spec.ts │ │ │ ├── comparators.spec.ts │ │ │ ├── dynamic_view.spec.ts │ │ │ ├── eventEmitter.spec.ts │ │ │ ├── joins.spec.ts │ │ │ ├── operator_packages.spec.ts │ │ │ ├── ops.spec.ts │ │ │ ├── persistence.spec.ts │ │ │ ├── remove.spec.ts │ │ │ ├── sortingIndexing.spec.ts │ │ │ ├── stage.spec.ts │ │ │ ├── stats.spec.ts │ │ │ ├── test.spec.ts │ │ │ ├── transforms.spec.ts │ │ │ ├── typed.spec.ts │ │ │ └── unique.spec.ts │ │ ├── src/ │ │ │ ├── avl_index.ts │ │ │ ├── clone.ts │ │ │ ├── collection.ts │ │ │ ├── comparators.ts │ │ │ ├── dynamic_view.ts │ │ │ ├── event_emitter.ts │ │ │ ├── index.ts │ │ │ ├── loki.ts │ │ │ ├── operator_packages.ts │ │ │ ├── ranged_indexes.ts │ │ │ ├── result_set.ts │ │ │ └── unique_index.ts │ │ └── webpack.config.js │ ├── memory-storage/ │ │ ├── package.json │ │ ├── spec/ │ │ │ └── generic/ │ │ │ └── memory_storage.spec.ts │ │ ├── src/ │ │ │ ├── index.ts │ │ │ └── memory_storage.ts │ │ └── webpack.config.js │ └── partitioning-adapter/ │ ├── package.json │ ├── spec/ │ │ └── generic/ │ │ └── partitioning.spec.ts │ ├── src/ │ │ ├── index.ts │ │ └── partitioning_adapter.ts │ └── webpack.config.js ├── scripts/ │ ├── build.ts │ ├── common.ts │ └── deploy.ts └── tsconfig.json
Showing preview only (239K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2799 symbols across 447 files)
FILE: benchmark/benchmark.js
function genRandomVal (line 11) | function genRandomVal() {
function createDatabase (line 19) | function createDatabase(mode) {
function populateDatabase (line 50) | function populateDatabase(db, count) {
function benchUniquePerf (line 77) | function benchUniquePerf(count, multiple) {
function testperfGet (line 131) | function testperfGet(count, multiple) {
function testperfFind (line 186) | function testperfFind(mode, count, multiple) {
function testperfRS (line 231) | function testperfRS(mode, count, multiple) {
function testperfDV (line 277) | function testperfDV(mode, count, multiple) {
function cleanup (line 335) | function cleanup() {
function execSteps (line 383) | function execSteps(steps) {
function execGroups (line 401) | function execGroups() {
FILE: benchmark/benchmark_indexes.js
function genRandomVal (line 24) | function genRandomVal() {
function shuffle (line 32) | function shuffle(array) {
function formatBytes (line 56) | function formatBytes(bytes, decimals) {
function logMemoryUsage (line 69) | function logMemoryUsage(msg) {
function createDatabase (line 78) | function createDatabase(mode) {
function populateDatabase (line 104) | function populateDatabase(db, count) {
function profileDatabaseMemory (line 131) | function profileDatabaseMemory(mode, count) {
function profileInsertion (line 157) | function profileInsertion(mode, count) {
function perfFind (line 199) | function perfFind(mode, count) {
function perfFindInterlacedInserts (line 236) | function perfFindInterlacedInserts(mode, count) {
function perfFindInterlacedRemoves (line 292) | function perfFindInterlacedRemoves(mode, count, multiple) {
function perfFindInterlacesUpdates (line 335) | function perfFindInterlacesUpdates(mode, count) {
function cleanup (line 382) | function cleanup() {
function execSteps (line 479) | function execSteps(steps) {
function execGroups (line 492) | function execGroups() {
FILE: dist/packages/fs-storage/lokidb.fs-storage.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function getGlobal (line 109) | function getGlobal() {
function create (line 116) | function create() {
class FSStorage (line 172) | class FSStorage {
method register (line 176) | static register() {
method deregister (line 182) | static deregister() {
method loadDatabase (line 190) | loadDatabase(dbname) {
method saveDatabase (line 217) | saveDatabase(dbname, dbstring) {
method deleteDatabase (line 243) | deleteDatabase(dbname) {
FILE: dist/packages/fs-storage/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/fs-storage/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/fs-storage/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/fs-storage/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/fs-storage/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/fs-storage/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/fs-storage/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/fs-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/fs-storage/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/fs-storage/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/fs-storage/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/fs-storage/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/fs-storage/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/fs-storage/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/fs-storage/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/fs-storage/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/fs-storage/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/fs-storage/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/fs-storage/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/fs-storage/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/fs-storage/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/fs-storage/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/fs-storage/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/fs-storage/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/fs-storage/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/fs-storage/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/fs-storage/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/full-text-search-language-de/lokidb.full-text-search-language-de.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
class german_analyzer_GermanStemmer (line 115) | class german_analyzer_GermanStemmer {
method constructor (line 116) | constructor() {
function splitter (line 396) | function splitter(str) {
function stemmer (line 407) | function stemmer(token) {
class GermanAnalyzer (line 415) | class GermanAnalyzer {
method constructor (line 416) | constructor() {
FILE: dist/packages/full-text-search-language-de/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/full-text-search-language-de/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/full-text-search-language-de/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language-de/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language-de/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/full-text-search-language-de/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/full-text-search-language-de/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/full-text-search-language-de/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/full-text-search-language-de/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/full-text-search-language-de/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/full-text-search-language-de/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/full-text-search-language-de/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/full-text-search-language-de/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/full-text-search-language-de/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/full-text-search-language-de/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/full-text-search-language-de/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/full-text-search-language-de/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/full-text-search-language-de/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/full-text-search-language-de/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/full-text-search-language-de/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/full-text-search-language-de/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/full-text-search-language-en/lokidb.full-text-search-language-en.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
class EnglishStemmer (line 115) | class EnglishStemmer {
method constructor (line 116) | constructor() {
function splitter (line 310) | function splitter(str) {
function stemmer (line 321) | function stemmer(token) {
class EnglishAnalyzer (line 327) | class EnglishAnalyzer {
method constructor (line 328) | constructor() {
FILE: dist/packages/full-text-search-language-en/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/full-text-search-language-en/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/full-text-search-language-en/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language-en/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language-en/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/full-text-search-language-en/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/full-text-search-language-en/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/full-text-search-language-en/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/full-text-search-language-en/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/full-text-search-language-en/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/full-text-search-language-en/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/full-text-search-language-en/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/full-text-search-language-en/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/full-text-search-language-en/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/full-text-search-language-en/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/full-text-search-language-en/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/full-text-search-language-en/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/full-text-search-language-en/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/full-text-search-language-en/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/full-text-search-language-en/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/full-text-search-language-en/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/full-text-search-language/lokidb.full-text-search-language.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function generateTrimmer (line 109) | function generateTrimmer(wordCharacters) {
function generateStopWordFilter (line 113) | function generateStopWordFilter(stopWords) {
class Among (line 117) | class Among {
method constructor (line 118) | constructor(s, substring_i, result, method) {
class SnowballProgram (line 133) | class SnowballProgram {
method constructor (line 134) | constructor() {
method setCurrent (line 142) | setCurrent(word) {
method getCurrent (line 150) | getCurrent() {
method in_grouping (line 155) | in_grouping(s, min, max) {
method in_grouping_b (line 168) | in_grouping_b(s, min, max) {
method out_grouping (line 181) | out_grouping(s, min, max) {
method out_grouping_b (line 196) | out_grouping_b(s, min, max) {
method eq_s (line 211) | eq_s(s_size, s) {
method eq_s_b (line 223) | eq_s_b(s_size, s) {
method find_among (line 235) | find_among(v, v_size) {
method find_among_b (line 293) | find_among_b(v, v_size) {
method replace_s (line 348) | replace_s(c_bra, c_ket, s) {
method slice_check (line 361) | slice_check() {
method slice_from (line 367) | slice_from(s) {
method slice_del (line 371) | slice_del() {
method insert (line 374) | insert(c_bra, c_ket, s) {
method slice_to (line 381) | slice_to() {
method eq_v_b (line 385) | eq_v_b(s) {
FILE: dist/packages/full-text-search-language/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/full-text-search-language/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/full-text-search-language/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/full-text-search-language/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/full-text-search-language/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/full-text-search-language/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/full-text-search-language/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/full-text-search-language/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/full-text-search-language/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/full-text-search-language/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/full-text-search-language/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/full-text-search-language/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/full-text-search-language/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/full-text-search-language/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/full-text-search-language/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/full-text-search-language/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/full-text-search-language/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/full-text-search-language/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/full-text-search-language/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/full-text-search-language/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/full-text-search-language/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/full-text-search-language/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/full-text-search-language/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/full-text-search/lokidb.full-text-search.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function getGlobal (line 103) | function getGlobal() {
function create (line 110) | function create() {
function whitespaceTokenizer (line 138) | function whitespaceTokenizer(value) {
function lowercaseTokenFilter (line 148) | function lowercaseTokenFilter(token) {
function uppercaseTokenFilter (line 156) | function uppercaseTokenFilter(token) {
function analyze (line 169) | function analyze(analyzer, str) {
class analyzer_StandardAnalyzer (line 189) | class analyzer_StandardAnalyzer {
method constructor (line 190) | constructor() {
function toCodePoints (line 204) | function toCodePoints(str) {
class inverted_index_InvertedIndex (line 224) | class inverted_index_InvertedIndex {
method constructor (line 231) | constructor(options = {}) {
method insert (line 247) | insert(field, docId) {
method remove (line 305) | remove(docId) {
method getTermIndex (line 365) | static getTermIndex(term, root, start = 0) {
method extendTermIndex (line 385) | static extendTermIndex(idx, term = [], termIndices = []) {
method toJSON (line 401) | toJSON() {
method fromJSONObject (line 422) | static fromJSONObject(serialized, analyzer) {
method _serializeIndex (line 439) | static _serializeIndex(idx) {
method _deserializeIndex (line 457) | static _deserializeIndex(serialized) {
method _regenerate (line 475) | _regenerate(index, parent) {
method _remove (line 507) | _remove(idx, docId) {
class Scorer (line 534) | class Scorer {
method constructor (line 535) | constructor(invIdxs) {
method setDirty (line 539) | setDirty() {
method score (line 542) | score(fieldName, boost, termIdx, doScoring, queryResults, term, df = 0) {
method scoreConstant (line 565) | scoreConstant(boost, docId, queryResults) {
method finalScore (line 572) | finalScore(query, queryResults) {
method _calculateFieldLength (line 632) | static _calculateFieldLength(fieldLength) {
method _getCache (line 636) | _getCache(fieldName) {
method _idf (line 650) | _idf(fieldName, docFreq) {
method _avgFieldLength (line 657) | _avgFieldLength(fieldName) {
class RunAutomaton (line 667) | class RunAutomaton {
method constructor (line 668) | constructor(automaton) {
method getCharClass (line 688) | getCharClass(c) {
method step (line 706) | step(state, c) {
method isAccept (line 714) | isAccept(state) {
function sortByDestMinMax (line 730) | function sortByDestMinMax(a, b) {
function sortByMinMaxDest (line 751) | function sortByMinMaxDest(a, b) {
class Automaton (line 776) | class Automaton {
method constructor (line 777) | constructor() {
method isAccept (line 786) | isAccept(n) {
method createState (line 789) | createState() {
method setAccept (line 792) | setAccept(state, accept) {
method finishState (line 800) | finishState() {
method _finishCurrentState (line 806) | _finishCurrentState() {
method getStartPoints (line 863) | getStartPoints() {
method step (line 879) | step(state, label) {
method getNumStates (line 891) | getNumStates() {
method addTransition (line 894) | addTransition(source, dest, min, max) {
class Long (line 911) | class Long {
method constructor (line 912) | constructor(low = 0, high = 0) {
method shiftRight (line 921) | shiftRight(numBits) {
method shiftLeft (line 934) | shiftLeft(numBits) {
method and (line 947) | and(other) {
method toInt (line 954) | toInt() {
class ParametricDescription (line 981) | class ParametricDescription {
method constructor (line 982) | constructor(w, n, minErrors) {
method size (line 990) | size() {
method isAccept (line 996) | isAccept(absState) {
method getPosition (line 1007) | getPosition(absState) {
method unpack (line 1010) | static unpack(data, index, bitsPerValue) {
class lev1t_parametric_description_Lev1TParametricDescription (line 1053) | class lev1t_parametric_description_Lev1TParametricDescription extends Pa...
method constructor (line 1054) | constructor(w) {
method transition (line 1057) | transition(absState, position, vector) {
class lev2t_parametric_description_Lev2TParametricDescription (line 1276) | class lev2t_parametric_description_Lev2TParametricDescription extends Pa...
method constructor (line 1277) | constructor(w) {
method transition (line 1280) | transition(absState, position, vector) {
class levenshtein_automata_LevenshteinAutomata (line 1348) | class levenshtein_automata_LevenshteinAutomata {
method constructor (line 1349) | constructor(input, editDistance) {
method toAutomaton (line 1385) | toAutomaton() {
method _getVector (line 1423) | _getVector(x, pos, end) {
function calculateMinShouldMatch (line 1441) | function calculateMinShouldMatch(optionalClauseCount, spec) {
class index_searcher_IndexSearcher (line 1478) | class index_searcher_IndexSearcher {
method constructor (line 1484) | constructor(invIdxs, docs) {
method search (line 1489) | search(query) {
method setDirty (line 1501) | setDirty() {
method _recursive (line 1504) | _recursive(query, doScoring) {
method _getUnique (line 1680) | _getUnique(queries, doScoring, queryResults) {
method _getAll (line 1701) | _getAll(queries, doScoring, queryResults = new Map()) {
function calculateLevenshteinDistance (line 1724) | function calculateLevenshteinDistance(a, b) {
function fuzzySearch (line 1763) | function fuzzySearch(query, root) {
function wildcardSearch (line 1881) | function wildcardSearch(query, root) {
class full_text_search_FullTextSearch (line 1939) | class full_text_search_FullTextSearch {
method constructor (line 1951) | constructor(fieldOptions = [], id) {
method register (line 1965) | static register() {
method addDocument (line 1968) | addDocument(doc, id = doc[this._id]) {
method removeDocument (line 1990) | removeDocument(doc, id = doc[this._id]) {
method updateDocument (line 1998) | updateDocument(doc, id = doc[this._id]) {
method clear (line 2002) | clear() {
method search (line 2007) | search(query) {
method toJSON (line 2010) | toJSON() {
method fromJSONObject (line 2019) | static fromJSONObject(serialized, analyzers = {}) {
FILE: dist/packages/full-text-search/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/full-text-search/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/full-text-search/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/full-text-search/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/full-text-search/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/full-text-search/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/full-text-search/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/full-text-search/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/full-text-search/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/full-text-search/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/full-text-search/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/full-text-search/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/full-text-search/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/full-text-search/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/full-text-search/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/full-text-search/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/full-text-search/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/full-text-search/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/full-text-search/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/full-text-search/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/full-text-search/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/full-text-search/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/full-text-search/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/full-text-search/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/full-text-search/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/full-text-search/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/full-text-search/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/full-text-search/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/indexed-storage/lokidb.indexed-storage.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function getGlobal (line 103) | function getGlobal() {
function create (line 110) | function create() {
class indexed_storage_IndexedStorage (line 144) | class indexed_storage_IndexedStorage {
method register (line 148) | static register() {
method deregister (line 154) | static deregister() {
method constructor (line 160) | constructor(appname = "loki") {
method loadDatabase (line 179) | loadDatabase(dbname) {
method saveDatabase (line 217) | saveDatabase(dbname, dbstring) {
method deleteDatabase (line 260) | deleteDatabase(dbname) {
method deleteDatabasePartitions (line 289) | deleteDatabasePartitions(dbname) {
method getDatabaseList (line 311) | getDatabaseList(callback) {
method getCatalogSummary (line 343) | getCatalogSummary(callback) {
class LokiCatalog (line 391) | class LokiCatalog {
method constructor (line 392) | constructor(callback) {
method initializeLokiCatalog (line 396) | initializeLokiCatalog(callback) {
method getAppKey (line 434) | getAppKey(app, key, callback) {
method getAppKeyById (line 467) | getAppKeyById(id, callback, data) {
method setAppKey (line 480) | setAppKey(app, key, val, callback) {
method deleteAppKey (line 533) | deleteAppKey(id, callback) {
method getAppKeys (line 553) | getAppKeys(app, callback) {
method getAllKeys (line 591) | getAllKeys(callback) {
FILE: dist/packages/indexed-storage/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/indexed-storage/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/indexed-storage/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/indexed-storage/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/indexed-storage/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/indexed-storage/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/indexed-storage/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/indexed-storage/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/indexed-storage/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/indexed-storage/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/indexed-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/indexed-storage/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/indexed-storage/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/indexed-storage/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/indexed-storage/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/indexed-storage/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/indexed-storage/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/indexed-storage/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/indexed-storage/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/indexed-storage/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/indexed-storage/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/indexed-storage/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/indexed-storage/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/indexed-storage/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/indexed-storage/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/indexed-storage/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/indexed-storage/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/indexed-storage/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/indexed-storage/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/indexed-storage/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/local-storage/lokidb.local-storage.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function getGlobal (line 103) | function getGlobal() {
function create (line 110) | function create() {
class local_storage_LocalStorage (line 141) | class local_storage_LocalStorage {
method register (line 145) | static register() {
method deregister (line 151) | static deregister() {
method loadDatabase (line 159) | loadDatabase(dbname) {
method saveDatabase (line 168) | saveDatabase(dbname, dbstring) {
method deleteDatabase (line 177) | deleteDatabase(dbname) {
FILE: dist/packages/local-storage/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/local-storage/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/local-storage/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/local-storage/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/local-storage/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/local-storage/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/local-storage/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/local-storage/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/local-storage/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/local-storage/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/local-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/local-storage/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/local-storage/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/local-storage/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/local-storage/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/local-storage/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/local-storage/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/local-storage/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/local-storage/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/local-storage/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/local-storage/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/local-storage/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/local-storage/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/local-storage/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/local-storage/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/local-storage/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/local-storage/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/local-storage/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/local-storage/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/local-storage/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/loki/lokidb.loki.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function CreateJavascriptComparator (line 121) | function CreateJavascriptComparator() {
function CreateAbstractJavascriptComparator (line 131) | function CreateAbstractJavascriptComparator() {
function CreateAbstractDateJavascriptComparator (line 144) | function CreateAbstractDateJavascriptComparator() {
function CreateLokiComparator (line 156) | function CreateLokiComparator() {
function getGlobal (line 173) | function getGlobal() {
function create (line 180) | function create() {
function aeqHelper (line 222) | function aeqHelper(prop1, prop2) {
function ltHelper (line 294) | function ltHelper(prop1, prop2, equal) {
function gtHelper (line 386) | function gtHelper(prop1, prop2, equal) {
function sortHelper (line 478) | function sortHelper(prop1, prop2, descending) {
class LokiOperatorPackage (line 494) | class LokiOperatorPackage {
method $eq (line 498) | $eq(a, b) {
method $ne (line 501) | $ne(a, b) {
method $gt (line 504) | $gt(a, b) {
method $gte (line 507) | $gte(a, b) {
method $lt (line 510) | $lt(a, b) {
method $lte (line 513) | $lte(a, b) {
method $between (line 516) | $between(a, range) {
method $in (line 521) | $in(a, b) {
method $nin (line 524) | $nin(a, b) {
method $keyin (line 527) | $keyin(a, b) {
method $nkeyin (line 530) | $nkeyin(a, b) {
method $definedin (line 533) | $definedin(a, b) {
method $undefinedin (line 536) | $undefinedin(a, b) {
method $regex (line 539) | $regex(a, b) {
method $containsNone (line 542) | $containsNone(a, b) {
method $containsAny (line 545) | $containsAny(a, b) {
method $contains (line 552) | $contains(a, b) {
method $type (line 559) | $type(a, b) {
method $finite (line 571) | $finite(a, b) {
method $size (line 574) | $size(a, b) {
method $len (line 580) | $len(a, b) {
method $where (line 586) | $where(a, b) {
method $not (line 593) | $not(a, b) {
method $and (line 596) | $and(a, b) {
method $or (line 604) | $or(a, b) {
method doQueryOp (line 612) | doQueryOp(val, op) {
method containsCheckFn (line 620) | containsCheckFn(a) {
class LokiAbstractOperatorPackage (line 633) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
method constructor (line 634) | constructor() {
method $eq (line 637) | $eq(a, b) {
method $ne (line 640) | $ne(a, b) {
method $gt (line 643) | $gt(a, b) {
method $gte (line 646) | $gte(a, b) {
method $lt (line 649) | $lt(a, b) {
method $lte (line 652) | $lte(a, b) {
method $between (line 655) | $between(a, range) {
class ComparatorOperatorPackage (line 664) | class ComparatorOperatorPackage extends LokiOperatorPackage {
method constructor (line 665) | constructor(comparator) {
method $eq (line 669) | $eq(a, b) {
method $ne (line 672) | $ne(a, b) {
method $gt (line 675) | $gt(a, b) {
method $gte (line 678) | $gte(a, b) {
method $lt (line 681) | $lt(a, b) {
method $lte (line 684) | $lte(a, b) {
method $between (line 687) | $between(a, range) {
class UniqueIndex (line 712) | class UniqueIndex {
method constructor (line 717) | constructor(propertyField) {
method set (line 727) | set(id, value) {
method get (line 744) | get(value) {
method update (line 752) | update(id, value) {
method remove (line 768) | remove(id) {
method clear (line 779) | clear() {
function add (line 786) | function add(copy, key, value) {
function walk (line 796) | function walk(target, copy) {
function deepCopy (line 828) | function deepCopy(target) {
function clone (line 842) | function clone(data, method = "parse-stringify") {
function resolveTransformObject (line 888) | function resolveTransformObject(subObj, params, depth = 0) {
function resolveTransformParams (line 906) | function resolveTransformParams(transform, params) {
class result_set_ResultSet (line 948) | class result_set_ResultSet {
method constructor (line 953) | constructor(collection) {
method reset (line 965) | reset() {
method toJSON (line 975) | toJSON() {
method limit (line 986) | limit(qty) {
method offset (line 1000) | offset(pos) {
method copy (line 1013) | copy() {
method transform (line 1025) | transform(transform, parameters) {
method sort (line 1095) | sort(comparefun) {
method simplesort (line 1114) | simplesort(propname, options = { desc: false }) {
method compoundsort (line 1159) | compoundsort(properties) {
method _compoundeval (line 1195) | _compoundeval(properties, obj1, obj2) {
method sortByScoring (line 1211) | sortByScoring(ascending = false) {
method getScoring (line 1227) | getScoring() {
method findOr (line 1245) | findOr(expressionArray) {
method $or (line 1272) | $or(expressionArray) {
method findAnd (line 1283) | findAnd(expressionArray) {
method $and (line 1294) | $and(expressionArray) {
method find (line 1304) | find(query, firstOnly = false) {
method where (line 1517) | where(fun) {
method count (line 1554) | count() {
method data (line 1571) | data(options = {}) {
method update (line 1644) | update(updateFunction) {
method remove (line 1671) | remove() {
method mapReduce (line 1687) | mapReduce(mapFunction, reduceFunction) {
method eqJoin (line 1708) | eqJoin(joinData, leftJoinKey, rightJoinKey, mapFun, dataOptions) {
method map (line 1769) | map(mapFun, dataOptions) {
class dynamic_view_DynamicView (line 1801) | class dynamic_view_DynamicView extends event_emitter["a" /* LokiEventEmi...
method constructor (line 1811) | constructor(collection, name, options = {}) {
method _rematerialize (line 1852) | _rematerialize({ removeWhereFilters = false }) {
method branchResultSet (line 1893) | branchResultSet(transform, parameters) {
method toJSON (line 1903) | toJSON() {
method fromJSONObject (line 1917) | static fromJSONObject(collection, obj) {
method removeFilters (line 1938) | removeFilters({ queueSortPhase = false } = {}) {
method applySort (line 1968) | applySort(comparefun) {
method applySimpleSort (line 1988) | applySimpleSort(field, options = false) {
method applySortCriteria (line 2008) | applySortCriteria(criteria) {
method applySortByScoring (line 2020) | applySortByScoring(ascending = false) {
method getScoring (line 2032) | getScoring() {
method startTransaction (line 2039) | startTransaction() {
method commit (line 2047) | commit() {
method rollback (line 2055) | rollback() {
method _indexOfFilterWithId (line 2070) | _indexOfFilterWithId(uid) {
method _addFilter (line 2084) | _addFilter(filter) {
method reapplyFilters (line 2093) | reapplyFilters() {
method applyFilter (line 2119) | applyFilter(filter) {
method applyFind (line 2146) | applyFind(query, uid = "") {
method applyWhere (line 2160) | applyWhere(fun, uid) {
method removeFilter (line 2173) | removeFilter(uid) {
method count (line 2186) | count() {
method data (line 2206) | data(options = {}) {
method _queueRebuildEvent (line 2219) | _queueRebuildEvent() {
method _queueSortPhase (line 2236) | _queueSortPhase() {
method _performSortPhase (line 2257) | _performSortPhase(options = {}) {
method _evaluateDocument (line 2293) | _evaluateDocument(objIndex, isNew) {
method _removeDocument (line 2383) | _removeDocument(objIndex) {
method mapReduce (line 2442) | mapReduce(mapFunction, reduceFunction) {
function average (line 2468) | function average(array) {
function standardDeviation (line 2471) | function standardDeviation(values) {
function getNestedPropertyValue (line 2489) | function getNestedPropertyValue(obj, path, array, pathIdx = 0) {
class collection_Collection (line 2514) | class collection_Collection extends event_emitter["a" /* LokiEventEmitte...
method constructor (line 2536) | constructor(name, options = {}) {
method toJSON (line 2682) | toJSON() {
method fromJSONObject (line 2707) | static fromJSONObject(obj, options) {
method addTransform (line 2801) | addTransform(name, transform) {
method getTransform (line 2811) | getTransform(name) {
method setTransform (line 2819) | setTransform(name, transform) {
method removeTransform (line 2826) | removeTransform(name) {
method setTTL (line 2832) | setTTL(age, interval) {
method _prepareFullDocIndex (line 2856) | _prepareFullDocIndex() {
method ensureIndex (line 2869) | ensureIndex(field, indexTypeName, comparatorName) {
method ensureRangedIndex (line 2878) | ensureRangedIndex(field, indexTypeName, comparatorName) {
method ensureUniqueIndex (line 2899) | ensureUniqueIndex(field) {
method count (line 2913) | count(query) {
method _ensureId (line 2922) | _ensureId() {
method addDynamicView (line 2937) | addDynamicView(name, options) {
method removeDynamicView (line 2946) | removeDynamicView(name) {
method getDynamicView (line 2958) | getDynamicView(name) {
method findAndUpdate (line 2971) | findAndUpdate(filterObject, updateFunction) {
method findAndRemove (line 2978) | findAndRemove(filterObject) {
method insert (line 2981) | insert(doc) {
method insertOne (line 3008) | insertOne(doc, bulkInsert = false) {
method _defineNestedProperties (line 3059) | _defineNestedProperties(data) {
method clear (line 3088) | clear({ removeIndices: removeIndices = false } = {}) {
method update (line 3122) | update(doc) {
method _add (line 3191) | _add(obj) {
method updateWhere (line 3262) | updateWhere(filterFunction, updateFunction) {
method removeWhere (line 3278) | removeWhere(filterFunction) {
method removeDataOnly (line 3281) | removeDataOnly() {
method remove (line 3288) | remove(doc) {
method getChanges (line 3354) | getChanges() {
method setChangesApi (line 3362) | setChangesApi(disableChangesApi, disableDeltaChangesApi = true) {
method flushChanges (line 3369) | flushChanges() {
method _getObjectDelta (line 3372) | _getObjectDelta(oldObject, newObject) {
method _getChangeDelta (line 3400) | _getChangeDelta(obj, old) {
method _createChange (line 3412) | _createChange(name, op, obj, old) {
method _createInsertChange (line 3421) | _createInsertChange(obj) {
method _createUpdateChange (line 3424) | _createUpdateChange(obj, old) {
method _insertMetaWithChange (line 3427) | _insertMetaWithChange(obj) {
method _updateMetaWithChange (line 3431) | _updateMetaWithChange(obj, old) {
method _insertMeta (line 3435) | _insertMeta(obj) {
method _updateMeta (line 3449) | _updateMeta(obj) {
method get (line 3456) | get(id, returnPosition = false) {
method by (line 3494) | by(field, value) {
method findOne (line 3510) | findOne(query) {
method chain (line 3534) | chain(transform, parameters) {
method find (line 3548) | find(query) {
method findOneUnindexed (line 3555) | findOneUnindexed(prop, value) {
method startTransaction (line 3572) | startTransaction() {
method commit (line 3595) | commit() {
method rollback (line 3607) | rollback() {
method where (line 3646) | where(fun) {
method mapReduce (line 3655) | mapReduce(mapFunction, reduceFunction) {
method eqJoin (line 3670) | eqJoin(joinData, leftJoinProp, rightJoinProp, mapFun, dataOptions) {
method getStage (line 3677) | getStage(name) {
method stage (line 3689) | stage(stageName, obj) {
method commitStage (line 3700) | commitStage(stageName, message) {
method extract (line 3718) | extract(field) {
method min (line 3730) | min(field) {
method max (line 3738) | max(field) {
method minRecord (line 3746) | minRecord(field) {
method maxRecord (line 3772) | maxRecord(field) {
method extractNumerical (line 3798) | extractNumerical(field) {
method avg (line 3806) | avg(field) {
method stdDev (line 3814) | stdDev(field) {
method mode (line 3822) | mode(field) {
method median (line 3847) | median(field) {
class AvlTreeIndex (line 3875) | class AvlTreeIndex {
method constructor (line 3879) | constructor(name, comparator) {
method backup (line 3885) | backup() {
method restore (line 3891) | restore(tree) {
method insert (line 3902) | insert(id, val) {
method insertNode (line 3927) | insertNode(current, node) {
method updateBalance (line 3988) | updateBalance(node) {
method leftLeftCase (line 3999) | leftLeftCase(node) {
method leftRightCase (line 4006) | leftRightCase(node) {
method rightRightCase (line 4017) | rightRightCase(node) {
method rightLeftCase (line 4024) | rightLeftCase(node) {
method rotateLeft (line 4035) | rotateLeft(node) {
method rotateRight (line 4077) | rotateRight(node) {
method getValuesAsTree (line 4115) | getValuesAsTree(node) {
method update (line 4134) | update(id, val) {
method remove (line 4147) | remove(id) {
method removeNode (line 4158) | removeNode(node, id) {
method updateChildLink (line 4286) | updateChildLink(parentId, oldChildId, newChildId) {
method promoteChild (line 4303) | promoteChild(parent, child) {
method promoteSuccessor (line 4324) | promoteSuccessor(node) {
method findGreaterLeaf (line 4386) | findGreaterLeaf(node) {
method findLesserLeaf (line 4397) | findLesserLeaf(node) {
method rangeRequest (line 4408) | rangeRequest(range) {
method collateRequest (line 4433) | collateRequest(node, range) {
method collateIds (line 4543) | collateIds(node) {
method locate (line 4589) | locate(node, val) {
method validateIndex (line 4612) | validateIndex() {
method validateNode (line 4653) | validateNode(node) {
class LokiEventEmitter (line 4719) | class LokiEventEmitter {
method constructor (line 4720) | constructor() {
method on (line 4737) | on(eventName, listener) {
method emit (line 4759) | emit(eventName, ...data) {
method addListener (line 4776) | addListener(eventName, listener) {
method removeListener (line 4784) | removeListener(eventName, listener) {
function getENV (line 4816) | function getENV() {
class Loki (line 4841) | class Loki extends _event_emitter__WEBPACK_IMPORTED_MODULE_0__[/* LokiEv...
method constructor (line 4853) | constructor(filename = "loki.db", options = {}) {
method initializePersistence (line 4923) | initializePersistence(options = {}) {
method copy (line 4987) | copy(options = {}) {
method addCollection (line 5020) | addCollection(name, options = {}) {
method loadCollection (line 5032) | loadCollection(collection) {
method getCollection (line 5043) | getCollection(name) {
method renameCollection (line 5059) | renameCollection(oldName, newName) {
method listCollections (line 5066) | listCollections() {
method removeCollection (line 5080) | removeCollection(collectionName) {
method serialize (line 5100) | serialize(options = {}) {
method toJSON (line 5116) | toJSON() {
method serializeDestructured (line 5145) | serializeDestructured(options = {}) {
method serializeCollection (line 5250) | serializeCollection(options = {}) {
method deserializeDestructured (line 5288) | deserializeDestructured(destructuredSource, options = {}) {
method deserializeCollection (line 5370) | deserializeCollection(destructuredSource, options = {}) {
method loadJSON (line 5400) | loadJSON(serializedDb, options) {
method loadJSONObject (line 5422) | loadJSONObject(dbObject, options = {}) {
method close (line 5436) | close() {
method generateChangesNotification (line 5468) | generateChangesNotification(arrayOfCollectionNames) {
method serializeChanges (line 5483) | serializeChanges(collectionNamesArray) {
method clearChanges (line 5489) | clearChanges() {
method throttledSaveDrain (line 5506) | throttledSaveDrain(options = {}) {
method _loadDatabase (line 5557) | _loadDatabase(options = {}, ignore_not_found = false) {
method loadDatabase (line 5603) | loadDatabase(options = {}) {
method _saveDatabase (line 5620) | _saveDatabase() {
method saveDatabase (line 5652) | saveDatabase() {
method deleteDatabase (line 5679) | deleteDatabase() {
method _autosaveDirty (line 5693) | _autosaveDirty() {
method _autosaveClearFlags (line 5704) | _autosaveClearFlags() {
method _autosaveEnable (line 5712) | _autosaveEnable() {
method _autosaveDisable (line 5732) | _autosaveDisable() {
FILE: dist/packages/loki/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/loki/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/loki/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/loki/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/loki/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/loki/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/loki/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/loki/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/loki/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/loki/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/loki/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/loki/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/loki/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/loki/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/loki/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/loki/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/loki/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/loki/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/loki/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/loki/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/loki/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/loki/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/loki/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/loki/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/loki/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/loki/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/loki/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/loki/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/loki/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/loki/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/memory-storage/lokidb.memory-storage.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function getGlobal (line 103) | function getGlobal() {
function create (line 110) | function create() {
class memory_storage_MemoryStorage (line 141) | class memory_storage_MemoryStorage {
method register (line 145) | static register() {
method deregister (line 151) | static deregister() {
method constructor (line 159) | constructor(options) {
method loadDatabase (line 176) | loadDatabase(dbname) {
method saveDatabase (line 206) | saveDatabase(dbname, dbstring) {
method deleteDatabase (line 237) | deleteDatabase(dbname) {
FILE: dist/packages/memory-storage/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/memory-storage/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/memory-storage/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/memory-storage/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/memory-storage/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/memory-storage/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/memory-storage/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/memory-storage/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/memory-storage/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/memory-storage/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/memory-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/memory-storage/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/memory-storage/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/memory-storage/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/memory-storage/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/memory-storage/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/memory-storage/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/memory-storage/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/memory-storage/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/memory-storage/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/memory-storage/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/memory-storage/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/memory-storage/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/memory-storage/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/memory-storage/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/memory-storage/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/memory-storage/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/memory-storage/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/memory-storage/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/memory-storage/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: dist/packages/partitioning-adapter/lokidb.partitioning-adapter.js
function __webpack_require__ (line 16) | function __webpack_require__(moduleId) {
function getGlobal (line 103) | function getGlobal() {
function create (line 110) | function create() {
class partitioning_adapter_PartitioningAdapter (line 157) | class partitioning_adapter_PartitioningAdapter {
method register (line 161) | static register() {
method deregister (line 167) | static deregister() {
method constructor (line 176) | constructor(adapter, { paging = false, pageSize = 25 * 1024 * 1024, de...
method loadDatabase (line 205) | loadDatabase(dbname) {
method _loadNextPartition (line 233) | _loadNextPartition(partition) {
method _loadNextPage (line 254) | _loadNextPage() {
method exportDatabase (line 302) | exportDatabase(dbname, dbref) {
method _saveNextPartition (line 319) | _saveNextPartition() {
method _saveNextPage (line 355) | _saveNextPage() {
FILE: dist/packages/partitioning-adapter/types/common/types.d.ts
type StorageAdapter (line 5) | interface StorageAdapter {
type Doc (line 12) | type Doc<T extends object = object> = T & {
type Dict (line 21) | interface Dict<T> {
FILE: dist/packages/partitioning-adapter/types/fs-storage/src/fs_storage.d.ts
class FSStorage (line 5) | class FSStorage implements StorageAdapter {
FILE: dist/packages/partitioning-adapter/types/full-text-search-language-de/src/german_analyzer.d.ts
class GermanAnalyzer (line 2) | class GermanAnalyzer implements Analyzer {
FILE: dist/packages/partitioning-adapter/types/full-text-search-language-en/src/english_analyzer.d.ts
class EnglishAnalyzer (line 2) | class EnglishAnalyzer implements Analyzer {
FILE: dist/packages/partitioning-adapter/types/full-text-search-language/src/language.d.ts
class Among (line 3) | class Among {
class SnowballProgram (line 11) | class SnowballProgram {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/analyzer/analyzer.d.ts
type Analyzer (line 7) | interface Analyzer {
class StandardAnalyzer (line 31) | class StandardAnalyzer implements Analyzer {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/analyzer/character_filter.d.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/analyzer/token_filter.d.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/analyzer/tokenizer.d.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/full_text_search.d.ts
class FullTextSearch (line 6) | class FullTextSearch {
type FieldOptions (line 36) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 39) | interface Serialization {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/automaton.d.ts
type Transition (line 5) | type Transition = [number, number, number];
class Automaton (line 20) | class Automaton {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts
class Lev1TParametricDescription (line 6) | class Lev1TParametricDescription extends ParametricDescription {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts
class Lev2TParametricDescription (line 6) | class Lev2TParametricDescription extends ParametricDescription {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts
class LevenshteinAutomata (line 6) | class LevenshteinAutomata {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/long.d.ts
class Long (line 6) | class Long {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/parametric_description.d.ts
class ParametricDescription (line 6) | class ParametricDescription {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/fuzzy/run_automaton.d.ts
class RunAutomaton (line 6) | class RunAutomaton {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/index_searcher.d.ts
class IndexSearcher (line 8) | class IndexSearcher {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/inverted_index.d.ts
class InvertedIndex (line 13) | class InvertedIndex {
type FieldOptions (line 85) | interface FieldOptions {
type Index (line 90) | type Index = Map<number, any> & {
type IndexTerm (line 95) | type IndexTerm = {
type SerializedIndex (line 99) | interface SerializedIndex {
type Serialization (line 107) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 108) | type SpareSerialization = {
type FullSerialization (line 112) | type FullSerialization = {
type DocStore (line 120) | interface DocStore {
type DocumentIndex (line 124) | type DocumentIndex = number | string;
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/query_types.d.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 11) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 18) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 25) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 34) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 44) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 52) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 59) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 71) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 76) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 82) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 92) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 96) | interface Query {
FILE: dist/packages/partitioning-adapter/types/full-text-search/src/scorer.d.ts
class Scorer (line 7) | class Scorer {
type IDFCache (line 28) | interface IDFCache {
type QueryResult (line 32) | interface QueryResult {
type QueryResults (line 39) | type QueryResults = Map<InvertedIndex.DocumentIndex, QueryResult[]>;
type BM25Explanation (line 40) | interface BM25Explanation {
type ConstantExplanation (line 52) | interface ConstantExplanation {
type ScoreExplanation (line 56) | type ScoreExplanation = BM25Explanation | ConstantExplanation;
type ScoreResult (line 57) | type ScoreResult = {
type ScoreResults (line 61) | type ScoreResults = Dict<ScoreResult>;
FILE: dist/packages/partitioning-adapter/types/indexed-storage/src/indexed_storage.d.ts
class IndexedStorage (line 9) | class IndexedStorage implements StorageAdapter {
type Entry (line 96) | interface Entry {
FILE: dist/packages/partitioning-adapter/types/local-storage/src/local_storage.d.ts
class LocalStorage (line 6) | class LocalStorage implements StorageAdapter {
FILE: dist/packages/partitioning-adapter/types/loki/src/avl_index.d.ts
type TreeNode (line 10) | type TreeNode<T> = {
type ITreeNodeHash (line 20) | interface ITreeNodeHash<T> {
class AvlTreeIndex (line 30) | class AvlTreeIndex<T> implements IRangedIndex<T> {
FILE: dist/packages/partitioning-adapter/types/loki/src/clone.d.ts
type CloneMethod (line 1) | type CloneMethod = "parse-stringify" | "deep" | "shallow" | "shallow-rec...
FILE: dist/packages/partitioning-adapter/types/loki/src/collection.d.ts
class Collection (line 16) | class Collection<TData extends object = object, TNested extends object =...
type Options (line 466) | interface Options<TData extends object, TNested extends object = {}, T e...
type RangedIndexOptions (line 488) | interface RangedIndexOptions {
type DeserializeOptions (line 491) | interface DeserializeOptions {
type BinaryIndex (line 499) | interface BinaryIndex {
type RangedIndexMeta (line 503) | interface RangedIndexMeta {
type Change (line 508) | interface Change {
type Serialized (line 513) | interface Serialized {
type CheckIndexOptions (line 539) | interface CheckIndexOptions {
type Transform (line 544) | type Transform<T extends object = object> = {
type TTL (line 590) | interface TTL {
FILE: dist/packages/partitioning-adapter/types/loki/src/comparators.d.ts
type ILokiComparer (line 1) | interface ILokiComparer<T> {
type IComparatorMap (line 4) | interface IComparatorMap {
FILE: dist/packages/partitioning-adapter/types/loki/src/dynamic_view.d.ts
class DynamicView (line 24) | class DynamicView<T extends object = object> extends LokiEventEmitter {
type Options (line 246) | interface Options {
type SortPriority (line 251) | type SortPriority = "passive" | "active";
type Serialized (line 252) | interface Serialized {
type Filter (line 267) | type Filter<T extends object = object> = {
FILE: dist/packages/partitioning-adapter/types/loki/src/event_emitter.d.ts
class LokiEventEmitter (line 8) | class LokiEventEmitter {
FILE: dist/packages/partitioning-adapter/types/loki/src/loki.d.ts
class Loki (line 7) | class Loki extends LokiEventEmitter {
type Options (line 286) | interface Options {
type PersistenceOptions (line 294) | interface PersistenceOptions {
type CopyOptions (line 303) | interface CopyOptions {
type SerializeOptions (line 306) | interface SerializeOptions {
type SerializeDestructuredOptions (line 309) | interface SerializeDestructuredOptions {
type DeserializeCollectionOptions (line 315) | interface DeserializeCollectionOptions {
type ThrottledDrainOptions (line 320) | interface ThrottledDrainOptions {
type Serialized (line 326) | interface Serialized {
type LoadDatabaseOptions (line 339) | type LoadDatabaseOptions = Collection.DeserializeOptions & ThrottledDrai...
type SerializationMethod (line 340) | type SerializationMethod = "normal" | "pretty" | "destructured";
type PersistenceMethod (line 341) | type PersistenceMethod = "fs-storage" | "local-storage" | "indexed-stora...
type Environment (line 342) | type Environment = "NATIVESCRIPT" | "NODEJS" | "CORDOVA" | "BROWSER" | "...
FILE: dist/packages/partitioning-adapter/types/loki/src/operator_packages.d.ts
type ILokiOperatorPackageMap (line 3) | interface ILokiOperatorPackageMap {
class LokiOperatorPackage (line 48) | class LokiOperatorPackage {
class LokiAbstractOperatorPackage (line 80) | class LokiAbstractOperatorPackage extends LokiOperatorPackage {
class ComparatorOperatorPackage (line 93) | class ComparatorOperatorPackage<T> extends LokiOperatorPackage {
FILE: dist/packages/partitioning-adapter/types/loki/src/ranged_indexes.d.ts
type RangedValueOperator (line 2) | type RangedValueOperator = "$gt" | "$gte" | "$lt" | "$lte" | "$eq" | "$n...
type IRangedIndexRequest (line 3) | interface IRangedIndexRequest<T> {
type IRangedIndex (line 9) | interface IRangedIndex<T> {
type IRangedIndexFactoryMap (line 19) | interface IRangedIndexFactoryMap {
FILE: dist/packages/partitioning-adapter/types/loki/src/result_set.d.ts
class ResultSet (line 19) | class ResultSet<T extends object = object> {
type DataOptions (line 211) | interface DataOptions {
type SimpleSortOptions (line 216) | interface SimpleSortOptions {
type ContainsHelperType (line 220) | type ContainsHelperType<R> = R extends string ? string | string[] : R ex...
type LokiOps (line 221) | type LokiOps<R> = {
type Query (line 266) | type Query<T> = {
FILE: dist/packages/partitioning-adapter/types/loki/src/unique_index.d.ts
class UniqueIndex (line 1) | class UniqueIndex {
FILE: dist/packages/partitioning-adapter/types/memory-storage/src/memory_storage.d.ts
class MemoryStorage (line 6) | class MemoryStorage implements StorageAdapter {
type Options (line 53) | interface Options {
FILE: dist/packages/partitioning-adapter/types/partitioning-adapter/src/partitioning_adapter.d.ts
class PartitioningAdapter (line 13) | class PartitioningAdapter implements StorageAdapter {
FILE: docs/js/codemirror/addon/edit/matchbrackets.js
function findMatchingBracket (line 19) | function findMatchingBracket(cm, where, config) {
function scanForBracket (line 49) | function scanForBracket(cm, where, dir, style, config) {
function matchBrackets (line 76) | function matchBrackets(cm, autoclear, config) {
function doMatchBrackets (line 106) | function doMatchBrackets(cm) {
FILE: docs/js/codemirror/addon/fold/brace-fold.js
function findOpening (line 18) | function findOpening(openCh) {
function hasImport (line 63) | function hasImport(line) {
function hasInclude (line 87) | function hasInclude(line) {
FILE: docs/js/codemirror/addon/fold/foldcode.js
function doFold (line 14) | function doFold(cm, pos, options, force) {
function makeWidget (line 61) | function makeWidget(cm, options) {
function getOption (line 138) | function getOption(cm, options, name) {
FILE: docs/js/codemirror/addon/fold/foldgutter.js
function State (line 39) | function State(options) {
function parseOptions (line 44) | function parseOptions(opts) {
function isFolded (line 52) | function isFolded(cm, line) {
function marker (line 58) | function marker(spec) {
function updateFoldInfo (line 68) | function updateFoldInfo(cm, from, to) {
function updateInViewport (line 87) | function updateInViewport(cm) {
function onGutterClick (line 96) | function onGutterClick(cm, line, gutter) {
function onChange (line 106) | function onChange(cm) {
function onViewportChange (line 115) | function onViewportChange(cm) {
function onFold (line 139) | function onFold(cm, from) {
FILE: docs/js/codemirror/lib/codemirror.js
function classTest (line 50) | function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)...
function removeChildren (line 61) | function removeChildren(e) {
function removeChildrenAndAdd (line 67) | function removeChildrenAndAdd(parent, e) {
function elt (line 71) | function elt(tag, content, className, style) {
function eltP (line 80) | function eltP(tag, content, className, style) {
function contains (line 103) | function contains(parent, child) {
function activeElt (line 114) | function activeElt() {
function addClass (line 129) | function addClass(node, cls) {
function joinClasses (line 133) | function joinClasses(a, b) {
function bind (line 146) | function bind(f) {
function copyObj (line 151) | function copyObj(obj, target, overwrite) {
function countColumn (line 161) | function countColumn(string, end, tabSize, startIndex, startValue) {
function indexOf (line 182) | function indexOf(array, elt) {
function findColumn (line 202) | function findColumn(string, goal, tabSize) {
function spaceStr (line 217) | function spaceStr(n) {
function lst (line 223) | function lst(arr) { return arr[arr.length-1] }
function map (line 225) | function map(array, f) {
function insertSorted (line 231) | function insertSorted(array, value, score) {
function nothing (line 237) | function nothing() {}
function createObj (line 239) | function createObj(base, props) {
function isWordCharBasic (line 252) | function isWordCharBasic(ch) {
function isWordChar (line 256) | function isWordChar(ch, helper) {
function isEmpty (line 262) | function isEmpty(obj) {
function isExtendingChar (line 273) | function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendi...
function skipExtendingChars (line 276) | function skipExtendingChars(str, pos, dir) {
function findFirst (line 283) | function findFirst(pred, from, to) {
function Display (line 296) | function Display(place, doc, input) {
function getLine (line 396) | function getLine(doc, n) {
function getBetween (line 412) | function getBetween(doc, start, end) {
function getLines (line 424) | function getLines(doc, from, to) {
function updateLineHeight (line 432) | function updateLineHeight(line, height) {
function lineNo (line 439) | function lineNo(line) {
function lineAtHeight (line 453) | function lineAtHeight(chunk, h) {
function isLine (line 473) | function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}
function lineNumberFor (line 475) | function lineNumberFor(options, i) {
function Pos (line 480) | function Pos(line, ch, sticky) {
function cmp (line 491) | function cmp(a, b) { return a.line - b.line || a.ch - b.ch }
function equalCursorPos (line 493) | function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b)...
function copyPos (line 495) | function copyPos(x) {return Pos(x.line, x.ch)}
function maxPos (line 496) | function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }
function minPos (line 497) | function minPos(a, b) { return cmp(a, b) < 0 ? a : b }
function clipLine (line 501) | function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.fi...
function clipPos (line 502) | function clipPos(doc, pos) {
function clipToLen (line 508) | function clipToLen(pos, linelen) {
function clipPosArray (line 514) | function clipPosArray(doc, array) {
function seeReadOnlySpans (line 524) | function seeReadOnlySpans() {
function seeCollapsedSpans (line 528) | function seeCollapsedSpans() {
function MarkedSpan (line 534) | function MarkedSpan(marker, from, to) {
function getMarkedSpanFor (line 540) | function getMarkedSpanFor(spans, marker) {
function removeMarkedSpan (line 548) | function removeMarkedSpan(spans, span) {
function addMarkedSpan (line 555) | function addMarkedSpan(line, span) {
function markedSpansBefore (line 564) | function markedSpansBefore(old, startCh, isInsert) {
function markedSpansAfter (line 575) | function markedSpansAfter(old, endCh, isInsert) {
function stretchSpansOverChange (line 594) | function stretchSpansOverChange(doc, change) {
function clearEmptySpans (line 656) | function clearEmptySpans(spans) {
function removeReadOnlyRanges (line 667) | function removeReadOnlyRanges(doc, from, to) {
function detachMarkedSpans (line 696) | function detachMarkedSpans(line) {
function attachMarkedSpans (line 703) | function attachMarkedSpans(line, spans) {
function extraLeft (line 712) | function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }
function extraRight (line 713) | function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }
function compareCollapsedMarkers (line 718) | function compareCollapsedMarkers(a, b) {
function collapsedSpanAtSide (line 731) | function collapsedSpanAtSide(line, start) {
function collapsedSpanAtStart (line 741) | function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, t...
function collapsedSpanAtEnd (line 742) | function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, fal...
function conflictingCollapsedRange (line 747) | function conflictingCollapsedRange(doc, lineNo$$1, from, to, marker) {
function visualLine (line 767) | function visualLine(line) {
function visualLineEnd (line 774) | function visualLineEnd(line) {
function visualLineContinued (line 783) | function visualLineContinued(line) {
function visualLineNo (line 794) | function visualLineNo(doc, lineN) {
function visualLineEndNo (line 802) | function visualLineEndNo(doc, lineN) {
function lineIsHidden (line 814) | function lineIsHidden(doc, line) {
function lineIsHiddenInner (line 825) | function lineIsHiddenInner(doc, line, span) {
function heightAtLine (line 842) | function heightAtLine(lineObj) {
function lineLength (line 864) | function lineLength(line) {
function findMaxLine (line 883) | function findMaxLine(cm) {
function iterateBidiSections (line 899) | function iterateBidiSections(order, from, to, f) {
function getBidiPartAt (line 913) | function getBidiPartAt(order, ch, sticky) {
function charType (line 959) | function charType(code) {
function BidiSpan (line 972) | function BidiSpan(level, from, to) {
function getOrder (line 1102) | function getOrder(line, direction) {
function moveCharLogically (line 1108) | function moveCharLogically(line, ch, dir) {
function moveLogically (line 1113) | function moveLogically(line, start, dir) {
function endOfLine (line 1118) | function endOfLine(visually, cm, lineObj, lineNo, dir) {
function moveVisually (line 1145) | function moveVisually(cm, line, start, dir) {
function getHandlers (line 1232) | function getHandlers(emitter, type) {
function off (line 1236) | function off(emitter, type, f) {
function signal (line 1251) | function signal(emitter, type /*, values...*/) {
function signalDOMEvent (line 1261) | function signalDOMEvent(cm, e, override) {
function signalCursorActivity (line 1268) | function signalCursorActivity(cm) {
function hasHandler (line 1276) | function hasHandler(emitter, type) {
function eventMixin (line 1282) | function eventMixin(ctor) {
function e_preventDefault (line 1290) | function e_preventDefault(e) {
function e_stopPropagation (line 1294) | function e_stopPropagation(e) {
function e_defaultPrevented (line 1298) | function e_defaultPrevented(e) {
function e_stop (line 1301) | function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);}
function e_target (line 1303) | function e_target(e) {return e.target || e.srcElement}
function e_button (line 1304) | function e_button(e) {
function zeroWidthElement (line 1325) | function zeroWidthElement(measure) {
function hasBadBidiRects (line 1340) | function hasBadBidiRects(measure) {
function hasBadZoomedRects (line 1389) | function hasBadZoomedRects(measure) {
function defineMode (line 1404) | function defineMode(name, mode) {
function defineMIME (line 1410) | function defineMIME(mime, spec) {
function resolveMode (line 1416) | function resolveMode(spec) {
function getMode (line 1435) | function getMode(options, spec) {
function extendMode (line 1459) | function extendMode(mode, properties) {
function copyState (line 1464) | function copyState(mode, state) {
function innerMode (line 1478) | function innerMode(mode, state) {
function startState (line 1489) | function startState(mode, a1, a2) {
function highlightLine (line 1616) | function highlightLine(cm, line, context, forceToEnd) {
function getLineStyles (line 1658) | function getLineStyles(cm, line, updateFrontier) {
function getContextBefore (line 1674) | function getContextBefore(cm, n, precise) {
function processLine (line 1694) | function processLine(cm, text, context, startAt) {
function callBlankLine (line 1705) | function callBlankLine(mode, state) {
function readToken (line 1712) | function readToken(mode, stream, state, inner) {
function takeToken (line 1729) | function takeToken(cm, pos, precise, asArray) {
function extractLineClasses (line 1743) | function extractLineClasses(type, output) {
function runMode (line 1758) | function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {
function findStartLine (line 1802) | function findStartLine(cm, n, precise) {
function retreatFrontier (line 1819) | function retreatFrontier(doc, n) {
function updateLine (line 1852) | function updateLine(line, text, markedSpans, estimateHeight) {
function cleanUpLine (line 1864) | function cleanUpLine(line) {
function interpretTokenStyle (line 1874) | function interpretTokenStyle(style, options) {
function buildLineContent (line 1886) | function buildLineContent(cm, lineView) {
function defaultSpecialCharPlaceholder (line 1944) | function defaultSpecialCharPlaceholder(ch) {
function buildToken (line 1953) | function buildToken(builder, text, style, startStyle, endStyle, title, c...
function splitSpaces (line 2015) | function splitSpaces(text, trailingBefore) {
function buildTokenBadBidi (line 2030) | function buildTokenBadBidi(inner, order) {
function buildCollapsedSpan (line 2050) | function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
function insertLineContent (line 2068) | function insertLineContent(line, builder, styles) {
function LineView (line 2140) | function LineView(doc, line, lineN) {
function buildViewArray (line 2152) | function buildViewArray(cm, from, to) {
function pushOperation (line 2164) | function pushOperation(op) {
function fireCallbacksForOps (line 2175) | function fireCallbacksForOps(group) {
function finishOperation (line 2191) | function finishOperation(op, endCb) {
function signalLater (line 2211) | function signalLater(emitter, type /*, values...*/) {
function fireOrphanDelayed (line 2231) | function fireOrphanDelayed() {
function updateLineForChanges (line 2240) | function updateLineForChanges(cm, lineView, lineN, dims) {
function ensureLineWrapped (line 2253) | function ensureLineWrapped(lineView) {
function updateLineBackground (line 2264) | function updateLineBackground(cm, lineView) {
function getLineContent (line 2279) | function getLineContent(cm, lineView) {
function updateLineText (line 2292) | function updateLineText(cm, lineView) {
function updateLineClasses (line 2307) | function updateLineClasses(cm, lineView) {
function updateLineGutter (line 2317) | function updateLineGutter(cm, lineView, lineN, dims) {
function updateLineWidgets (line 2355) | function updateLineWidgets(cm, lineView, dims) {
function buildLineElement (line 2366) | function buildLineElement(cm, lineView, lineN, dims) {
function insertLineWidgets (line 2380) | function insertLineWidgets(cm, lineView, dims) {
function insertLineWidgetsFor (line 2386) | function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
function positionLineWidget (line 2402) | function positionLineWidget(widget, node, lineView, dims) {
function widgetHeight (line 2420) | function widgetHeight(widget) {
function eventInWidget (line 2436) | function eventInWidget(display, e) {
function paddingTop (line 2446) | function paddingTop(display) {return display.lineSpace.offsetTop}
function paddingVert (line 2447) | function paddingVert(display) {return display.mover.offsetHeight - displ...
function paddingH (line 2448) | function paddingH(display) {
function scrollGap (line 2457) | function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }
function displayWidth (line 2458) | function displayWidth(cm) {
function displayHeight (line 2461) | function displayHeight(cm) {
function ensureLineHeights (line 2469) | function ensureLineHeights(cm, lineView, rect) {
function mapFromLineView (line 2490) | function mapFromLineView(lineView, line, lineN) {
function updateExternalMeasurement (line 2503) | function updateExternalMeasurement(cm, line) {
function measureChar (line 2516) | function measureChar(cm, line, ch, bias) {
function findViewForLine (line 2521) | function findViewForLine(cm, lineN) {
function prepareMeasureForLine (line 2534) | function prepareMeasureForLine(cm, line) {
function measureCharPrepared (line 2556) | function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
function nodeAndOffsetInLineMap (line 2578) | function nodeAndOffsetInLineMap(map$$1, ch, bias) {
function getUsefulRect (line 2616) | function getUsefulRect(rects, bias) {
function measureCharInner (line 2626) | function measureCharInner(cm, prepared, ch, bias) {
function maybeUpdateRectForZooming (line 2679) | function maybeUpdateRectForZooming(measure, rect) {
function clearLineMeasurementCacheFor (line 2689) | function clearLineMeasurementCacheFor(lineView) {
function clearLineMeasurementCache (line 2698) | function clearLineMeasurementCache(cm) {
function clearCaches (line 2705) | function clearCaches(cm) {
function pageScrollX (line 2712) | function pageScrollX() {
function pageScrollY (line 2719) | function pageScrollY() {
function intoCoordSystem (line 2728) | function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {
function fromCoordSystem (line 2750) | function fromCoordSystem(cm, coords, context) {
function charCoords (line 2767) | function charCoords(cm, pos, context, lineObj, bias) {
function cursorCoords (line 2788) | function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHei...
function estimateCoords (line 2819) | function estimateCoords(cm, pos) {
function PosWithInfo (line 2834) | function PosWithInfo(line, ch, sticky, outside, xRel) {
function coordsChar (line 2843) | function coordsChar(cm, x, y) {
function wrappedLineExtent (line 2864) | function wrappedLineExtent(cm, lineObj, preparedMeasure, y) {
function wrappedLineExtentChar (line 2872) | function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {
function coordsCharInner (line 2877) | function coordsCharInner(cm, lineObj, lineNo$$1, x, y) {
function textHeight (line 2940) | function textHeight(display) {
function charWidth (line 2960) | function charWidth(display) {
function getDimensions (line 2972) | function getDimensions(cm) {
function compensateForHScroll (line 2989) | function compensateForHScroll(display) {
function estimateHeight (line 2996) | function estimateHeight(cm) {
function estimateLineHeights (line 3014) | function estimateLineHeights(cm) {
function posFromMouse (line 3027) | function posFromMouse(cm, e, liberal, forRect) {
function findViewIndex (line 3045) | function findViewIndex(cm, n) {
function updateSelection (line 3056) | function updateSelection(cm) {
function prepareSelection (line 3060) | function prepareSelection(cm, primary) {
function drawSelectionCursor (line 3079) | function drawSelectionCursor(cm, head, output) {
function drawSelectionRange (line 3098) | function drawSelectionRange(cm, range$$1, output) {
function restartBlink (line 3171) | function restartBlink(cm) {
function ensureFocus (line 3184) | function ensureFocus(cm) {
function delayBlurEvent (line 3188) | function delayBlurEvent(cm) {
function onFocus (line 3196) | function onFocus(cm, e) {
function onBlur (line 3215) | function onBlur(cm, e) {
function updateHeightsInViewport (line 3229) | function updateHeightsInViewport(cm) {
function updateWidgetHeight (line 3256) | function updateWidgetHeight(line) {
function visibleLines (line 3264) | function visibleLines(display, doc, viewport) {
function alignHorizontally (line 3287) | function alignHorizontally(cm) {
function maybeUpdateLineNumberWidth (line 3310) | function maybeUpdateLineNumberWidth(cm) {
function maybeScrollWindow (line 3332) | function maybeScrollWindow(cm, rect) {
function scrollPosIntoView (line 3349) | function scrollPosIntoView(cm, pos, end, margin) {
function scrollIntoView (line 3383) | function scrollIntoView(cm, rect) {
function calculateScrollPos (line 3393) | function calculateScrollPos(cm, rect) {
function addToScrollTop (line 3423) | function addToScrollTop(cm, top) {
function ensureCursorVisible (line 3431) | function ensureCursorVisible(cm) {
function scrollToCoords (line 3437) | function scrollToCoords(cm, x, y) {
function scrollToRange (line 3443) | function scrollToRange(cm, range$$1) {
function resolveScrollToPos (line 3452) | function resolveScrollToPos(cm) {
function scrollToCoordsRange (line 3461) | function scrollToCoordsRange(cm, from, to, margin) {
function updateScrollTop (line 3473) | function updateScrollTop(cm, val) {
function setScrollTop (line 3481) | function setScrollTop(cm, val, forceScroll) {
function setScrollLeft (line 3491) | function setScrollLeft(cm, val, isScroller, forceScroll) {
function measureForScrollbars (line 3504) | function measureForScrollbars(cm) {
function maybeDisable (line 3595) | function maybeDisable() {
function updateScrollbars (line 3624) | function updateScrollbars(cm, measure) {
function updateScrollbarsInner (line 3638) | function updateScrollbarsInner(cm, measure) {
function initScrollbars (line 3660) | function initScrollbars(cm) {
function startOperation (line 3690) | function startOperation(cm) {
function endOperation (line 3712) | function endOperation(cm) {
function endOperations (line 3723) | function endOperations(group) {
function endOperation_R1 (line 3737) | function endOperation_R1(op) {
function endOperation_W1 (line 3750) | function endOperation_W1(op) {
function endOperation_R2 (line 3754) | function endOperation_R2(op) {
function endOperation_W2 (line 3775) | function endOperation_W2(op) {
function endOperation_finish (line 3800) | function endOperation_finish(op) {
function runInOp (line 3839) | function runInOp(cm, f) {
function operation (line 3846) | function operation(cm, f) {
function methodOp (line 3856) | function methodOp(f) {
function docMethodOp (line 3864) | function docMethodOp(f) {
function regChange (line 3880) | function regChange(cm, from, to, lendiff) {
function regLineChange (line 3945) | function regLineChange(cm, line, type) {
function resetView (line 3959) | function resetView(cm) {
function viewCuttingPoint (line 3965) | function viewCuttingPoint(cm, oldN, newN, dir) {
function adjustView (line 3992) | function adjustView(cm, from, to) {
function countDirtyView (line 4013) | function countDirtyView(cm) {
function startWorker (line 4024) | function startWorker(cm, time) {
function highlightWorker (line 4029) | function highlightWorker(cm) {
function maybeClipScrollbars (line 4099) | function maybeClipScrollbars(cm) {
function selectionSnapshot (line 4110) | function selectionSnapshot(cm) {
function restoreSelection (line 4127) | function restoreSelection(snapshot) {
function updateDisplayIfNeeded (line 4143) | function updateDisplayIfNeeded(cm, update) {
function postUpdateDisplay (line 4215) | function postUpdateDisplay(cm, update) {
function updateDisplaySimple (line 4245) | function updateDisplaySimple(cm, viewport) {
function patchDisplay (line 4262) | function patchDisplay(cm, updateNumbersFrom, dims) {
function updateGutterSpace (line 4304) | function updateGutterSpace(cm) {
function setDocumentHeight (line 4309) | function setDocumentHeight(cm, measure) {
function updateGutters (line 4317) | function updateGutters(cm) {
function setGuttersForLineNumbers (line 4335) | function setGuttersForLineNumbers(options) {
function wheelEventDelta (line 4367) | function wheelEventDelta(e) {
function wheelEventPixels (line 4374) | function wheelEventPixels(e) {
function onScrollWheel (line 4381) | function onScrollWheel(cm, e) {
function normalizeSelection (line 4520) | function normalizeSelection(ranges, primIndex) {
function simpleSelection (line 4536) | function simpleSelection(anchor, head) {
function changeEnd (line 4542) | function changeEnd(change) {
function adjustForChange (line 4550) | function adjustForChange(pos, change) {
function computeSelAfterChange (line 4559) | function computeSelAfterChange(doc, change) {
function offsetPos (line 4569) | function offsetPos(pos, old, nw) {
function computeReplacedSel (line 4578) | function computeReplacedSel(doc, changes, hint) {
function loadMode (line 4599) | function loadMode(cm) {
function resetModeState (line 4604) | function resetModeState(cm) {
function isWholeLineUpdate (line 4620) | function isWholeLineUpdate(doc, change) {
function updateDoc (line 4626) | function updateDoc(doc, change, markedSpans, estimateHeight$$1) {
function linkedDocs (line 4678) | function linkedDocs(doc, f, sharedHistOnly) {
function attachDoc (line 4693) | function attachDoc(cm, doc) {
function setDirectionClass (line 4705) | function setDirectionClass(cm) {
function directionChanged (line 4709) | function directionChanged(cm) {
function History (line 4716) | function History(startGen) {
function historyChangeFromChange (line 4733) | function historyChangeFromChange(doc, change) {
function clearSelectionEvents (line 4742) | function clearSelectionEvents(array) {
function lastChangeEvent (line 4752) | function lastChangeEvent(hist, force) {
function addChangeToHistory (line 4767) | function addChangeToHistory(doc, change, selAfter, opId) {
function selectionEventCanBeMerged (line 4810) | function selectionEventCanBeMerged(doc, origin, prev, sel) {
function addSelectionToHistory (line 4823) | function addSelectionToHistory(doc, sel, opId, options) {
function pushSelectionToHistory (line 4845) | function pushSelectionToHistory(sel, dest) {
function attachLocalSpans (line 4852) | function attachLocalSpans(doc, change, from, to) {
function removeClearedSpans (line 4863) | function removeClearedSpans(spans) {
function getOldSpans (line 4874) | function getOldSpans(doc, change) {
function mergeOldSpans (line 4887) | function mergeOldSpans(doc, change) {
function copyHistoryArray (line 4911) | function copyHistoryArray(events, newGroup, instantiateSel) {
function extendRange (line 4943) | function extendRange(range, head, other, extend) {
function extendSelection (line 4962) | function extendSelection(doc, head, other, options, extend) {
function extendSelections (line 4969) | function extendSelections(doc, heads, options) {
function replaceOneSelection (line 4979) | function replaceOneSelection(doc, i, range, options) {
function setSimpleSelection (line 4986) | function setSimpleSelection(doc, anchor, head, options) {
function filterSelectionChange (line 4992) | function filterSelectionChange(doc, sel, options) {
function setSelectionReplaceHistory (line 5011) | function setSelectionReplaceHistory(doc, sel, options) {
function setSelection (line 5022) | function setSelection(doc, sel, options) {
function setSelectionNoUndo (line 5027) | function setSelectionNoUndo(doc, sel, options) {
function setSelectionInner (line 5039) | function setSelectionInner(doc, sel) {
function reCheckSelection (line 5053) | function reCheckSelection(doc) {
function skipAtomicInSelection (line 5059) | function skipAtomicInSelection(doc, sel, bias, mayClear) {
function skipAtomicInner (line 5074) | function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
function skipAtomic (line 5107) | function skipAtomic(doc, pos, oldPos, bias, mayClear) {
function movePos (line 5120) | function movePos(doc, pos, dir, line) {
function selectAll (line 5132) | function selectAll(cm) {
function filterChange (line 5139) | function filterChange(doc, change, update) {
function makeChange (line 5163) | function makeChange(doc, change, ignoreReadOnly) {
function makeChangeInner (line 5185) | function makeChangeInner(doc, change) {
function makeChangeFromHistory (line 5203) | function makeChangeFromHistory(doc, type, allowSelectionOnly) {
function shiftDoc (line 5276) | function shiftDoc(doc, distance) {
function makeChangeSingleDoc (line 5292) | function makeChangeSingleDoc(doc, change, selAfter, spans) {
function makeChangeSingleDocInEditor (line 5325) | function makeChangeSingleDocInEditor(cm, change, spans) {
function replaceRange (line 5383) | function replaceRange(doc, code, from, to, origin) {
function rebaseHistSelSingle (line 5392) | function rebaseHistSelSingle(pos, from, to, diff) {
function rebaseHistArray (line 5408) | function rebaseHistArray(array, from, to, diff) {
function rebaseHist (line 5436) | function rebaseHist(hist, change) {
function changeLine (line 5445) | function changeLine(doc, handle, changeType, op) {
function LeafChunk (line 5467) | function LeafChunk(lines) {
function BranchChunk (line 5520) | function BranchChunk(children) {
function adjustScrollWhenAboveVisible (line 5683) | function adjustScrollWhenAboveVisible(cm, line, diff) {
function addLineWidget (line 5688) | function addLineWidget(doc, handle, node, options) {
function markText (line 5847) | function markText(doc, from, to, options, type) {
function markTextShared (line 5945) | function markTextShared(doc, from, to, options, type) {
function findSharedMarkers (line 5960) | function findSharedMarkers(doc) {
function copySharedMarkers (line 5964) | function copySharedMarkers(doc, markers) {
function detachSharedMarkers (line 5976) | function detachSharedMarkers(markers) {
function onDrop (line 6418) | function onDrop(e) {
function onDragStart (line 6478) | function onDragStart(cm, e) {
function onDragOver (line 6501) | function onDragOver(cm, e) {
function clearDragCursor (line 6513) | function clearDragCursor(cm) {
function forEachCodeMirror (line 6524) | function forEachCodeMirror(f) {
function ensureGlobalHandlers (line 6534) | function ensureGlobalHandlers() {
function registerGlobalHandlers (line 6539) | function registerGlobalHandlers() {
function onResize (line 6552) | function onResize(cm) {
function normalizeKeyName (line 6625) | function normalizeKeyName(name) {
function normalizeKeyMap (line 6649) | function normalizeKeyMap(keymap) {
function lookupKey (line 6676) | function lookupKey(key, map$$1, handle, context) {
function isModifierKey (line 6695) | function isModifierKey(value) {
function addModifierNames (line 6700) | function addModifierNames(name, event, noShift) {
function keyName (line 6710) | function keyName(event, noShift) {
function getKeyMap (line 6717) | function getKeyMap(val) {
function deleteNearSelection (line 6723) | function deleteNearSelection(cm, compute) {
function lineStart (line 6889) | function lineStart(cm, lineN) {
function lineEnd (line 6895) | function lineEnd(cm, lineN) {
function lineStartSmart (line 6901) | function lineStartSmart(cm, pos) {
function doHandleBinding (line 6914) | function doHandleBinding(cm, bound, dropShift) {
function lookupKeyForEditor (line 6934) | function lookupKeyForEditor(cm, name, handle) {
function dispatchKey (line 6947) | function dispatchKey(cm, name, e, handle) {
function handleKeyBinding (line 6979) | function handleKeyBinding(cm, e) {
function handleCharBinding (line 6998) | function handleCharBinding(cm, e, ch) {
function onKeyDown (line 7003) | function onKeyDown(e) {
function showCrossHair (line 7024) | function showCrossHair(cm) {
function onKeyUp (line 7039) | function onKeyUp(e) {
function onKeyPress (line 7044) | function onKeyPress(e) {
function clickRepeat (line 7072) | function clickRepeat(pos, button) {
function onMouseDown (line 7093) | function onMouseDown(e) {
function handleMappedButton (line 7130) | function handleMappedButton(cm, button, pos, repeat, event) {
function configureMouse (line 7150) | function configureMouse(cm, repeat, event) {
function leftButtonDown (line 7163) | function leftButtonDown(cm, pos, repeat, event) {
function leftButtonStartDrag (line 7181) | function leftButtonStartDrag(cm, event, pos, behavior) {
function rangeForUnit (line 7220) | function rangeForUnit(cm, pos, unit) {
function leftButtonSelect (line 7229) | function leftButtonSelect(cm, event, start, behavior) {
function gutterEvent (line 7362) | function gutterEvent(cm, e, type, prevent) {
function clickInGutter (line 7386) | function clickInGutter(cm, e) {
function onContextMenu (line 7395) | function onContextMenu(cm, e) {
function contextMenuInGutter (line 7401) | function contextMenuInGutter(cm, e) {
function themeChanged (line 7406) | function themeChanged(cm) {
function defineOptions (line 7417) | function defineOptions(CodeMirror) {
function guttersChanged (line 7550) | function guttersChanged(cm) {
function dragDropChanged (line 7556) | function dragDropChanged(cm, value, old) {
function wrappingChanged (line 7569) | function wrappingChanged(cm) {
function CodeMirror$1 (line 7587) | function CodeMirror$1(place, options) {
function registerEventHandlers (line 7663) | function registerEventHandlers(cm) {
function indentLine (line 7778) | function indentLine(cm, n, how, aggressive) {
function setLastCopied (line 7842) | function setLastCopied(newLastCopied) {
function applyTextInput (line 7846) | function applyTextInput(cm, inserted, deleted, sel, origin) {
function handlePaste (line 7894) | function handlePaste(e, cm) {
function triggerElectric (line 7904) | function triggerElectric(cm, inserted) {
function copyableRanges (line 7928) | function copyableRanges(cm) {
function disableBrowserMagic (line 7939) | function disableBrowserMagic(field, spellcheck) {
function hiddenTextarea (line 7945) | function hiddenTextarea() {
function findPosH (line 8409) | function findPosH(doc, pos, dir, unit, visually) {
function findPosV (line 8469) | function findPosV(cm, pos, dir, unit) {
function onCopyCut (line 8532) | function onCopyCut(e) {
function poll (line 8686) | function poll() {
function posToDOM (line 8852) | function posToDOM(cm, pos) {
function isInGutter (line 8868) | function isInGutter(node) {
function badPos (line 8874) | function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }
function domTextBetween (line 8876) | function domTextBetween(cm, from, to, fromLine, toLine) {
function domToPos (line 8923) | function domToPos(cm, node, offset) {
function locateNodeInLineView (line 8942) | function locateNodeInLineView(lineView, node, offset) {
function prepareCopyCut (line 9045) | function prepareCopyCut(e) {
function p (line 9187) | function p() {
function prepareSelectAllHack (line 9290) | function prepareSelectAllHack() {
function rehide (line 9303) | function rehide() {
function fromTextArea (line 9349) | function fromTextArea(textarea, options) {
function addLegacyProps (line 9406) | function addLegacyProps(CodeMirror) {
FILE: docs/js/codemirror/mode/javascript/javascript.js
function expressionAllowed (line 14) | function expressionAllowed(stream, state, backUp) {
function kw (line 30) | function kw(type) {return {type: type, style: "keyword"};}
function readRegexp (line 79) | function readRegexp(stream) {
function ret (line 94) | function ret(tp, style, cont) {
function tokenBase (line 98) | function tokenBase(stream, state) {
function tokenString (line 163) | function tokenString(quote) {
function tokenComment (line 179) | function tokenComment(stream, state) {
function tokenQuasi (line 191) | function tokenQuasi(stream, state) {
function findFatArrow (line 211) | function findFatArrow(stream, state) {
function JSLexical (line 246) | function JSLexical(indented, column, type, align, prev, info) {
function inScope (line 255) | function inScope(state, varname) {
function parseJS (line 264) | function parseJS(state, style, type, content, stream) {
function pass (line 288) | function pass() {
function cont (line 291) | function cont() {
function register (line 295) | function register(varname) {
function pushcontext (line 316) | function pushcontext() {
function popcontext (line 320) | function popcontext() {
function pushlex (line 324) | function pushlex(type, info) {
function poplex (line 335) | function poplex() {
function expect (line 345) | function expect(wanted) {
function statement (line 354) | function statement(type, value) {
function expression (line 389) | function expression(type) {
function expressionNoComma (line 392) | function expressionNoComma(type) {
function parenExpr (line 395) | function parenExpr(type) {
function expressionInner (line 399) | function expressionInner(type, noComma) {
function maybeexpression (line 419) | function maybeexpression(type) {
function maybeexpressionNoComma (line 423) | function maybeexpressionNoComma(type) {
function maybeoperatorComma (line 428) | function maybeoperatorComma(type, value) {
function maybeoperatorNoComma (line 432) | function maybeoperatorNoComma(type, value, noComma) {
function quasi (line 448) | function quasi(type, value) {
function continueQuasi (line 453) | function continueQuasi(type) {
function arrowBody (line 460) | function arrowBody(type) {
function arrowBodyNoComma (line 464) | function arrowBodyNoComma(type) {
function maybeTarget (line 468) | function maybeTarget(noComma) {
function target (line 474) | function target(_, value) {
function targetNoComma (line 477) | function targetNoComma(_, value) {
function maybelabel (line 480) | function maybelabel(type) {
function property (line 484) | function property(type) {
function objprop (line 487) | function objprop(type, value) {
function getterSetter (line 510) | function getterSetter(type) {
function afterprop (line 515) | function afterprop(type) {
function commasep (line 519) | function commasep(what, end, sep) {
function contCommasep (line 537) | function contCommasep(what, end, info) {
function block (line 542) | function block(type) {
function maybetype (line 546) | function maybetype(type, value) {
function typeexpr (line 552) | function typeexpr(type) {
function maybeReturnType (line 558) | function maybeReturnType(type) {
function typeprop (line 561) | function typeprop(type, value) {
function typearg (line 573) | function typearg(type) {
function afterType (line 577) | function afterType(type, value) {
function vardef (line 583) | function vardef() {
function pattern (line 586) | function pattern(type, value) {
function proppattern (line 593) | function proppattern(type, value) {
function maybeAssign (line 603) | function maybeAssign(_type, value) {
function vardefCont (line 606) | function vardefCont(type) {
function maybeelse (line 609) | function maybeelse(type, value) {
function forspec (line 612) | function forspec(type) {
function forspec1 (line 615) | function forspec1(type) {
function formaybeinof (line 621) | function formaybeinof(_type, value) {
function forspec2 (line 625) | function forspec2(type, value) {
function forspec3 (line 630) | function forspec3(type) {
function functiondef (line 633) | function functiondef(type, value) {
function funarg (line 639) | function funarg(type) {
function classExpression (line 643) | function classExpression(type, value) {
function className (line 648) | function className(type, value) {
function classNameAfter (line 651) | function classNameAfter(type, value) {
function classBody (line 657) | function classBody(type, value) {
function classfield (line 678) | function classfield(type, value) {
function afterExport (line 684) | function afterExport(type, value) {
function exportField (line 690) | function exportField(type, value) {
function afterImport (line 694) | function afterImport(type) {
function importSpec (line 698) | function importSpec(type, value) {
function maybeMoreImports (line 704) | function maybeMoreImports(type) {
function maybeAs (line 707) | function maybeAs(_type, value) {
function maybeFrom (line 710) | function maybeFrom(_type, value) {
function arrayLiteral (line 713) | function arrayLiteral(type) {
function isContinuedStatement (line 718) | function isContinuedStatement(state, textAfter) {
FILE: docs/js/javascript_editor.js
class JavascriptEditor (line 5) | class JavascriptEditor {
method constructor (line 6) | constructor(source) {
method switchToViewMode (line 83) | switchToViewMode() {
method switchToEditMode (line 91) | switchToEditMode() {
method compile (line 99) | compile() {
method stringify (line 165) | static stringify(value) {
FILE: integration/spec/helper/integration.helper.js
constant ENVIRONMENT (line 2) | const ENVIRONMENT = (() => {
function loadScriptByTag (line 31) | function loadScriptByTag(src) {
function loadScript (line 41) | function loadScript(name) {
function loadLibrary (line 61) | function loadLibrary(name, dependencies) {
FILE: packages/common/plugin.ts
function getGlobal (line 1) | function getGlobal(): any {
function create (line 10) | function create(): void {
constant PLUGINS (line 23) | const PLUGINS = create();
FILE: packages/common/types.ts
type StorageAdapter (line 6) | interface StorageAdapter {
type Doc (line 18) | type Doc<T extends object = object> = T & {
type Dict (line 28) | interface Dict<T> {
FILE: packages/fs-storage/spec/node/fs_storage.spec.ts
type Name (line 7) | interface Name {
FILE: packages/fs-storage/src/fs_storage.ts
class FSStorage (line 8) | class FSStorage implements StorageAdapter {
method register (line 12) | static register(): void {
method deregister (line 19) | static deregister(): void {
method loadDatabase (line 28) | loadDatabase(dbname: string): Promise<any> {
method saveDatabase (line 54) | saveDatabase(dbname: string, dbstring: string): Promise<void> {
method deleteDatabase (line 79) | deleteDatabase(dbname: string): Promise<void> {
FILE: packages/full-text-search-language-de/src/german_analyzer.ts
class GermanStemmer (line 13) | class GermanStemmer {
method constructor (line 18) | constructor() {
function splitter (line 316) | function splitter(str: string) {
function stemmer (line 329) | function stemmer(token: string) {
class GermanAnalyzer (line 339) | class GermanAnalyzer implements Analyzer {
FILE: packages/full-text-search-language-en/src/english_analyzer.ts
class EnglishStemmer (line 11) | class EnglishStemmer {
method constructor (line 14) | constructor() {
function splitter (line 231) | function splitter(str: string) {
function stemmer (line 244) | function stemmer(token: string) {
class EnglishAnalyzer (line 252) | class EnglishAnalyzer implements Analyzer {
FILE: packages/full-text-search-language/spec/helper/create_lanuage_test.helper.ts
type LanguageTestData (line 5) | interface LanguageTestData {
function createLanguageTest (line 20) | function createLanguageTest(language: string, data: LanguageTestData) {
FILE: packages/full-text-search-language/src/language.ts
function generateTrimmer (line 5) | function generateTrimmer(wordCharacters: string) {
function generateStopWordFilter (line 10) | function generateStopWordFilter(stopWords: string[]) {
class Among (line 15) | class Among {
method constructor (line 22) | constructor(s: string, substring_i: number, result: number, method?: a...
class SnowballProgram (line 40) | class SnowballProgram {
method constructor (line 48) | constructor() {
method setCurrent (line 57) | setCurrent(word: string) {
method getCurrent (line 66) | getCurrent() {
method in_grouping (line 72) | in_grouping(s: number[], min: number, max: number) {
method in_grouping_b (line 86) | in_grouping_b(s: number[], min: number, max: number) {
method out_grouping (line 100) | out_grouping(s: number[], min: number, max: number) {
method out_grouping_b (line 116) | out_grouping_b(s: number[], min: number, max: number) {
method eq_s (line 132) | eq_s(s_size: number, s: string) {
method eq_s_b (line 145) | eq_s_b(s_size: number, s: string) {
method find_among (line 158) | find_among(v: Among[], v_size: number) {
method find_among_b (line 217) | find_among_b(v: Among[], v_size: number) {
method replace_s (line 274) | replace_s(c_bra: number, c_ket: number, s: string) {
method slice_check (line 290) | slice_check() {
method slice_from (line 297) | slice_from(s: string) {
method slice_del (line 302) | slice_del() {
method insert (line 306) | insert(c_bra: number, c_ket: number, s: string) {
method slice_to (line 314) | slice_to() {
method eq_v_b (line 319) | eq_v_b(s: string) {
FILE: packages/full-text-search/spec/generic/full_text_search.spec.ts
type User (line 70) | interface User {
FILE: packages/full-text-search/spec/node/MOCK_DATA.ts
constant DATA (line 1) | const DATA = [
FILE: packages/full-text-search/spec/node/QUERIES.ts
constant FIELD_NAME_1 (line 3) | const FIELD_NAME_1 = "msg";
constant QUERIES (line 5) | const QUERIES: { fts: QueryTypes, es: any, empty?: boolean, focus?: bool...
FILE: packages/full-text-search/spec/node/elasticsearch.spec.ts
constant INDEX_NAME (line 11) | const INDEX_NAME = "test_index";
constant INDEX_TYPE (line 12) | const INDEX_TYPE = "MockUp";
constant FIELD_NAME_1 (line 13) | const FIELD_NAME_1 = "msg";
function fieldLengthES5 (line 15) | function fieldLengthES5(fieldLength: number) {
function fieldLengthES6 (line 37) | function fieldLengthES6(fieldLength: number) {
function initES (line 226) | function initES() {
function initFTS (line 280) | function initFTS() {
FILE: packages/full-text-search/src/analyzer/analyzer.ts
type Analyzer (line 8) | interface Analyzer {
function analyze (line 29) | function analyze(analyzer: Analyzer, str: string): string[] {
class StandardAnalyzer (line 50) | class StandardAnalyzer implements Analyzer {
FILE: packages/full-text-search/src/analyzer/character_filter.ts
type CharacterFilter (line 4) | type CharacterFilter = (value: string) => string;
FILE: packages/full-text-search/src/analyzer/token_filter.ts
type TokenFilter (line 4) | type TokenFilter = (value: string, index: number, array: string[]) => st...
function lowercaseTokenFilter (line 11) | function lowercaseTokenFilter(token: string): string {
function uppercaseTokenFilter (line 20) | function uppercaseTokenFilter(token: string): string {
FILE: packages/full-text-search/src/analyzer/tokenizer.ts
type Tokenizer (line 4) | type Tokenizer = (value: string) => string[];
function whitespaceTokenizer (line 11) | function whitespaceTokenizer(value: string): string[] {
FILE: packages/full-text-search/src/full_text_search.ts
class FullTextSearch (line 9) | class FullTextSearch {
method register (line 20) | public static register(): void {
method constructor (line 35) | constructor(fieldOptions: FullTextSearch.FieldOptions[] = [], id?: str...
method addDocument (line 46) | public addDocument(doc: object, id: InvertedIndex.DocumentIndex = doc[...
method removeDocument (line 68) | public removeDocument(doc: object, id: InvertedIndex.DocumentIndex = d...
method updateDocument (line 77) | public updateDocument(doc: object, id: InvertedIndex.DocumentIndex = d...
method clear (line 82) | public clear(): void {
method search (line 88) | public search(query: Query): Scorer.ScoreResults {
method toJSON (line 92) | public toJSON(): FullTextSearch.Serialization {
method fromJSONObject (line 102) | public static fromJSONObject(serialized: FullTextSearch.Serialization,...
type FieldOptions (line 114) | interface FieldOptions extends InvertedIndex.FieldOptions {
type Serialization (line 118) | interface Serialization {
FILE: packages/full-text-search/src/fuzzy/automaton.ts
type Transition (line 5) | type Transition = [number, number, number];
constant MIN_CODE_POINT (line 11) | const MIN_CODE_POINT = 0;
constant MAX_CODE_POINT (line 16) | const MAX_CODE_POINT = 1114111;
function sortByDestMinMax (line 18) | function sortByDestMinMax(a: Transition, b: Transition) {
function sortByMinMaxDest (line 37) | function sortByMinMaxDest(a: Transition, b: Transition) {
class Automaton (line 60) | class Automaton {
method constructor (line 68) | constructor() {
method isAccept (line 77) | public isAccept(n: number): boolean {
method createState (line 81) | public createState(): number {
method setAccept (line 85) | public setAccept(state: number, accept: boolean): void {
method finishState (line 93) | public finishState(): void {
method _finishCurrentState (line 100) | private _finishCurrentState(): void {
method getStartPoints (line 162) | public getStartPoints(): number[] {
method step (line 180) | public step(state: number, label: number): number {
method getNumStates (line 193) | public getNumStates(): number {
method addTransition (line 197) | public addTransition(source: number, dest: number, min: number, max: n...
FILE: packages/full-text-search/src/fuzzy/lev1t_parametric_description.ts
class Lev1TParametricDescription (line 33) | class Lev1TParametricDescription extends ParametricDescription {
method constructor (line 34) | constructor(w: number) {
method transition (line 38) | public transition(absState: number, position: number, vector: number):...
FILE: packages/full-text-search/src/fuzzy/lev2t_parametric_description.ts
class Lev2TParametricDescription (line 181) | class Lev2TParametricDescription extends ParametricDescription {
method constructor (line 182) | constructor(w: number) {
method transition (line 186) | public transition(absState: number, position: number, vector: number):...
FILE: packages/full-text-search/src/fuzzy/levenshtein_automata.ts
class LevenshteinAutomata (line 9) | class LevenshteinAutomata {
method constructor (line 18) | constructor(input: number[], editDistance: number) {
method toAutomaton (line 56) | public toAutomaton(): Automaton {
method _getVector (line 105) | private _getVector(x: number, pos: number, end: number): number {
FILE: packages/full-text-search/src/fuzzy/long.ts
class Long (line 6) | class Long {
method constructor (line 10) | constructor(low: number = 0, high: number = 0) {
method shiftRight (line 20) | public shiftRight(numBits: number): Long {
method shiftLeft (line 34) | public shiftLeft(numBits: number): Long {
method and (line 48) | public and(other: Long): Long {
method toInt (line 56) | public toInt(): number {
FILE: packages/full-text-search/src/fuzzy/parametric_description.ts
constant MASKS (line 3) | const MASKS = [new Long(0x1), new Long(0x3), new Long(0x7), new Long(0xf),
class ParametricDescription (line 24) | class ParametricDescription {
method constructor (line 29) | constructor(w: number, n: number, minErrors: number[]) {
method size (line 38) | public size(): number {
method isAccept (line 45) | public isAccept(absState: number): boolean {
method getPosition (line 57) | public getPosition(absState: number): number {
method unpack (line 61) | public static unpack(data: Long[], index: number, bitsPerValue: number...
FILE: packages/full-text-search/src/fuzzy/run_automaton.ts
class RunAutomaton (line 7) | class RunAutomaton {
method constructor (line 13) | constructor(automaton: Automaton) {
method getCharClass (line 36) | public getCharClass(c: number): number {
method step (line 53) | public step(state: number, c: number): number {
method isAccept (line 61) | public isAccept(state: number): boolean {
FILE: packages/full-text-search/src/index_searcher.ts
function calculateMinShouldMatch (line 11) | function calculateMinShouldMatch(optionalClauseCount: number, spec: unde...
class IndexSearcher (line 50) | class IndexSearcher {
method constructor (line 60) | constructor(invIdxs: Dict<InvertedIndex>, docs: Set<InvertedIndex.Docu...
method search (line 66) | public search(query: Query): Scorer.ScoreResults {
method setDirty (line 81) | public setDirty() {
method _recursive (line 85) | private _recursive(query: any, doScoring: boolean | null) {
method _getUnique (line 266) | private _getUnique(queries: any[], doScoring: boolean | null, queryRes...
method _getAll (line 289) | private _getAll(queries: any[], doScoring: boolean | null, queryResult...
type FuzzyResult (line 304) | type FuzzyResult = { index: Index, term: number[], boost: number };
function calculateLevenshteinDistance (line 314) | function calculateLevenshteinDistance(a: number[], b: number[]): number {
function fuzzySearch (line 356) | function fuzzySearch(query: FuzzyQuery, root: Index): [FuzzyResult[], nu...
type WildcardResult (line 478) | type WildcardResult = { index: Index, term: number[] };
function wildcardSearch (line 486) | function wildcardSearch(query: WildcardQuery, root: Index): WildcardResu...
FILE: packages/full-text-search/src/inverted_index.ts
function toCodePoints (line 9) | function toCodePoints(str: string): number[] {
class InvertedIndex (line 29) | class InvertedIndex {
method constructor (line 45) | constructor(options: InvertedIndex.FieldOptions = {}) {
method insert (line 60) | public insert(field: string, docId: InvertedIndex.DocumentIndex): void {
method remove (line 125) | public remove(docId: InvertedIndex.DocumentIndex): void {
method getTermIndex (line 191) | public static getTermIndex(term: number[], root: InvertedIndex.Index, ...
method extendTermIndex (line 212) | public static extendTermIndex(idx: InvertedIndex.Index, term: number[]...
method toJSON (line 231) | public toJSON(): InvertedIndex.Serialization {
method fromJSONObject (line 253) | public static fromJSONObject(serialized: InvertedIndex.Serialization, ...
method _serializeIndex (line 274) | private static _serializeIndex(idx: InvertedIndex.Index): InvertedInde...
method _deserializeIndex (line 296) | private static _deserializeIndex(serialized: InvertedIndex.SerializedI...
method _regenerate (line 316) | private _regenerate(index: InvertedIndex.Index, parent: InvertedIndex....
method _remove (line 351) | private _remove(idx: InvertedIndex.Index, docId: InvertedIndex.Documen...
type FieldOptions (line 376) | interface FieldOptions {
type Index (line 382) | type Index = Map<number, any> & { dc?: Map<DocumentIndex, number>, df?: ...
type IndexTerm (line 384) | type IndexTerm = { index: Index, term: number[] };
type SerializedIndex (line 386) | interface SerializedIndex {
type Serialization (line 395) | type Serialization = SpareSerialization | FullSerialization;
type SpareSerialization (line 397) | type SpareSerialization = {
type FullSerialization (line 402) | type FullSerialization = {
type DocStore (line 411) | interface DocStore {
type DocumentIndex (line 416) | type DocumentIndex = number | string;
FILE: packages/full-text-search/src/query_types.ts
type BaseQuery (line 4) | interface BaseQuery<Type> {
type TermQuery (line 14) | interface TermQuery extends BaseQuery<"term"> {
type TermsQuery (line 24) | interface TermsQuery extends BaseQuery<"terms"> {
type WildcardQuery (line 34) | interface WildcardQuery extends BaseQuery<"wildcard"> {
type FuzzyQuery (line 47) | interface FuzzyQuery extends BaseQuery<"fuzzy"> {
type PrefixQuery (line 63) | interface PrefixQuery extends BaseQuery<"prefix"> {
type ExistsQuery (line 75) | interface ExistsQuery extends BaseQuery<"exists"> {
type MatchQuery (line 84) | interface MatchQuery extends BaseQuery<"match"> {
type MatchQueryAll (line 104) | interface MatchQueryAll extends BaseQuery<"match_all"> {
type ConstantScoreQuery (line 110) | interface ConstantScoreQuery extends BaseQuery<"constant_score"> {
type BoolQuery (line 117) | interface BoolQuery extends BaseQuery<"bool"> {
type QueryTypes (line 133) | type QueryTypes = BoolQuery | ConstantScoreQuery | TermQuery | TermsQuer...
type Query (line 139) | interface Query {
FILE: packages/full-text-search/src/scorer.ts
class Scorer (line 8) | class Scorer {
method constructor (line 12) | constructor(invIdxs: Dict<InvertedIndex>) {
method setDirty (line 16) | public setDirty(): void {
method score (line 20) | public score(fieldName: string, boost: number, termIdx: InvertedIndex....
method scoreConstant (line 45) | public scoreConstant(boost: number, docId: InvertedIndex.DocumentIndex,
method finalScore (line 54) | public finalScore(query: Query, queryResults: Scorer.QueryResults): Sc...
method _calculateFieldLength (line 115) | private static _calculateFieldLength(fieldLength: number): number {
method _getCache (line 120) | private _getCache(fieldName: string): Scorer.IDFCache {
method _idf (line 135) | private _idf(fieldName: string, docFreq: number): number {
method _avgFieldL
Condensed preview — 643 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (3,026K chars).
[
{
"path": ".editorconfig",
"chars": 147,
"preview": "root = true\n\n[*]\nend_of_line = lf\ninsert_final_newline = true\ntrim_trailing_whitespace = true\ncharset = utf-8\nindent_sty"
},
{
"path": ".github/ISSUE_TEMPLATE.md",
"chars": 1398,
"preview": "<!--\nPLEASE HELP US PROCESS GITHUB ISSUES FASTER BY PROVIDING THE FOLLOWING INFORMATION.\n\nISSUES MISSING IMPORTANT INFOR"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 1115,
"preview": "## PR Checklist\nPlease check if your PR fulfills the following requirements:\n\n- [ ] The commit message follows our guide"
},
{
"path": ".gitignore",
"chars": 167,
"preview": "# IDE\n.idea/\n\n# NODE\nnode_modules/\n\n# Tests\ncoverage/\n.nyc_output\n\n# Typescript\n.ts/\n\n# Build artifacts\nbuild/\ndist/pack"
},
{
"path": ".travis.yml",
"chars": 644,
"preview": "language: python\npython:\n - \"3.5\"\nnode_js:\n - \"10\"\n\ndist: trusty\nsudo: required\n\nenv:\n global:\n - GIT_NAME"
},
{
"path": "CHANGELOG.md",
"chars": 12497,
"preview": "<a name=\"2.1.0\"></a>\n# [2.1.0](https://github.com/LokiJS-Forge/LokiDB/compare/2.0.0...2.1.0) (2020-08-23)\n\n\n### Features"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3222,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "CONTRIBUTING.md",
"chars": 9151,
"preview": "<!-- This page is a modified version of [Angular's CONTRIBUTING.md](https://github.com/angular/angular/blob/master/CONTR"
},
{
"path": "DEVELOPER.md",
"chars": 2242,
"preview": "<!-- This page is a modified version of [Angular](https://github.com/angular/angular/blob/master/docs/DEVELOPER.md). -->"
},
{
"path": "LICENSE",
"chars": 12077,
"preview": "This text consists of three parts:\n\nPart I: Remarks regarding the license given in\nPart II: MIT License\nPart III: Apache"
},
{
"path": "README.md",
"chars": 4052,
"preview": "[![npm status][npm]][npm-url]\n[![build status][build]][build-url]\n[![coverage status][coverage]][coverage-url]\n\n# LokiDB"
},
{
"path": "benchmark/benchmark.js",
"chars": 10860,
"preview": "/**\n * Core, \"single object lookup\" benchmarks\n */\n\nlet Loki = require('../build/packages/loki/lokidb.loki.js').default,"
},
{
"path": "benchmark/benchmark_indexes.js",
"chars": 13898,
"preview": "/**\n * This module is to be used to benchmark loki binary index lifecycle\n *\n * Attempt to simulate and benchmark effect"
},
{
"path": "config/jasmine.json",
"chars": 378,
"preview": "{\n \"spec_dir\": \"packages/*/spec\",\n \"spec_files\": [\n \"generic/**/*.spec.[jt]s\",\n \"node/**/*.spec.[jt]s\"\n ],\n \"h"
},
{
"path": "config/karma.config.js",
"chars": 2144,
"preview": "/* global process, require, module, require */\nconst path = require(\"path\");\n\nmodule.exports = function (config) {\n con"
},
{
"path": "config/nycrc.json",
"chars": 121,
"preview": "{\n \"reporter\": [\n \"text-summary\",\n \"html\"\n ],\n \"report-dir\": \"./coverage/\",\n \"temp-directory\": \"./coverage/\"\n}"
},
{
"path": "config/nycrc.node.json",
"chars": 216,
"preview": "{\n \"extension\": [\n \".ts\"\n ],\n \"reporter\": [\n \"text-summary\",\n \"json\"\n ],\n \"exclude\": [\n \"**/*.helper.[j"
},
{
"path": "config/tsconfig.tslint.json",
"chars": 628,
"preview": "{\n \"compileOnSave\": false,\n \"compilerOptions\": {\n \"outDir\": \"../types/\",\n \"sourceMap\": true,\n \"declaration\": "
},
{
"path": "config/tsconfig.webpack.json",
"chars": 647,
"preview": "{\n \"compileOnSave\": false,\n \"compilerOptions\": {\n \"outDir\": \"../types/\",\n \"sourceMap\": true,\n \"declaration\": "
},
{
"path": "config/tslint.json",
"chars": 851,
"preview": "{\n \"rulesDirectory\": [\n \"../node_modules/vrsource-tslint-rules/rules\",\n \"../node_modules/tslint-eslint-rules/dist"
},
{
"path": "config/webpack-config-creator.js",
"chars": 1315,
"preview": "/* global __dirname, module, require */\nconst path = require(\"path\");\n\nmodule.exports = (options) => {\n if (options.ent"
},
{
"path": "dist/packages/fs-storage/lokidb.fs-storage.js",
"chars": 9225,
"preview": "(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object"
},
{
"path": "dist/packages/fs-storage/types/common/plugin.d.ts",
"chars": 55,
"preview": "/**\n * @hidden\n */\nexport declare const PLUGINS: void;\n"
},
{
"path": "dist/packages/fs-storage/types/common/types.d.ts",
"chars": 633,
"preview": "/**\n * @hidden\n */\nimport { Loki } from \"../loki/src/loki\";\nexport interface StorageAdapter {\n loadDatabase(dbname: s"
},
{
"path": "dist/packages/fs-storage/types/fs-storage/src/fs_storage.d.ts",
"chars": 1340,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists using node fs modu"
},
{
"path": "dist/packages/fs-storage/types/fs-storage/src/index.d.ts",
"chars": 90,
"preview": "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",
"chars": 1060,
"preview": "import { CharacterFilter } from \"./character_filter\";\nimport { Tokenizer, whitespaceTokenizer } from \"./tokenizer\";\nimpo"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/character_filter.d.ts",
"chars": 162,
"preview": "/**\n * A character filter is used to preprocess a string before it is passed to a tokenizer.\n */\nexport declare type Cha"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/token_filter.d.ts",
"chars": 567,
"preview": "/**\n * A token filter takes tokens from a tokenizer and modify, delete or add tokens.\n */\nexport declare type TokenFilte"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/analyzer/tokenizer.d.ts",
"chars": 333,
"preview": "/**\n * A tokenizer splits a string into individual tokens.\n */\nexport declare type Tokenizer = (value: string) => string"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/full_text_search.d.ts",
"chars": 1871,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/automaton.d.ts",
"chars": 896,
"preview": "/**\n * Transition with dest, min and max.\n * @hidden\n */\nexport declare type Transition = [number, number, number];\n/**\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev1TPara"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev2TPara"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts",
"chars": 544,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidde"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/long.d.ts",
"chars": 994,
"preview": "/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nexport declare "
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/parametric_description.d.ts",
"chars": 844,
"preview": "import { Long } from \"./long\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescripti"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/fuzzy/run_automaton.d.ts",
"chars": 406,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\ne"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/index.d.ts",
"chars": 414,
"preview": "import { FullTextSearch } from \"./full_text_search\";\nimport { analyze, StandardAnalyzer } from \"./analyzer/analyzer\";\nim"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/index_searcher.d.ts",
"chars": 779,
"preview": "import { Scorer } from \"./scorer\";\nimport { InvertedIndex } from \"./inverted_index\";\nimport { Query } from \"./query_type"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/inverted_index.d.ts",
"chars": 4586,
"preview": "import { Analyzer } from \"./analyzer/analyzer\";\n/**\n * Converts a string into an array of code points.\n * @param str - t"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/query_types.d.ts",
"chars": 3038,
"preview": "/**\n * Base query to enable boost to a query type.\n */\nexport interface BaseQuery<Type> {\n type: Type;\n boost?: nu"
},
{
"path": "dist/packages/fs-storage/types/full-text-search/src/scorer.d.ts",
"chars": 2028,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language/src/index.d.ts",
"chars": 94,
"preview": "export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from \"./language\";\n"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language/src/language.d.ts",
"chars": 1367,
"preview": "export declare function generateTrimmer(wordCharacters: string): (token: string) => string;\nexport declare function gene"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-de/src/german_analyzer.d.ts",
"chars": 224,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class GermanAnalyzer implements "
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-de/src/index.d.ts",
"chars": 110,
"preview": "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",
"chars": 225,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class EnglishAnalyzer implements"
},
{
"path": "dist/packages/fs-storage/types/full-text-search-language-en/src/index.d.ts",
"chars": 114,
"preview": "import { EnglishAnalyzer } from \"./english_analyzer\";\nexport { EnglishAnalyzer };\nexport default EnglishAnalyzer;\n"
},
{
"path": "dist/packages/fs-storage/types/indexed-storage/src/index.d.ts",
"chars": 110,
"preview": "import { IndexedStorage } from \"./indexed_storage\";\nexport { IndexedStorage };\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/indexed-storage/src/indexed_storage.d.ts",
"chars": 3912,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * Loki persistence adapter class for indexedDb.\n * This cl"
},
{
"path": "dist/packages/fs-storage/types/local-storage/src/index.d.ts",
"chars": 102,
"preview": "import { LocalStorage } from \"./local_storage\";\nexport { LocalStorage };\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/local-storage/src/local_storage.d.ts",
"chars": 1453,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists to web browser's l"
},
{
"path": "dist/packages/fs-storage/types/loki/src/avl_index.d.ts",
"chars": 5526,
"preview": "import { IRangedIndex, IRangedIndexRequest } from \"./ranged_indexes\";\nimport { ILokiComparer } from \"./comparators\";\n/**"
},
{
"path": "dist/packages/fs-storage/types/loki/src/clone.d.ts",
"chars": 181,
"preview": "export declare type CloneMethod = \"parse-stringify\" | \"deep\" | \"shallow\" | \"shallow-recurse\";\n/**\n * @hidden\n */\nexport "
},
{
"path": "dist/packages/fs-storage/types/loki/src/collection.d.ts",
"chars": 23653,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { UniqueIndex } from \"./unique_index\";\nimport { ResultSet } f"
},
{
"path": "dist/packages/fs-storage/types/loki/src/comparators.d.ts",
"chars": 1014,
"preview": "export interface ILokiComparer<T> {\n (a: T, b: T): -1 | 0 | 1;\n}\nexport interface IComparatorMap {\n [name: string]"
},
{
"path": "dist/packages/fs-storage/types/loki/src/dynamic_view.d.ts",
"chars": 12701,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { ResultSet } from \"./result_set\";\nimport { Collection } from"
},
{
"path": "dist/packages/fs-storage/types/loki/src/event_emitter.d.ts",
"chars": 2014,
"preview": "/**\n * LokiEventEmitter is a minimalist version of EventEmitter. It enables any\n * constructor that inherits EventEmitte"
},
{
"path": "dist/packages/fs-storage/types/loki/src/index.d.ts",
"chars": 124,
"preview": "import { Loki } from \"./loki\";\nimport { Collection } from \"./collection\";\nexport { Loki, Collection };\nexport default Lo"
},
{
"path": "dist/packages/fs-storage/types/loki/src/loki.d.ts",
"chars": 17959,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { Collection } from \"./collection\";\nimport { Doc, StorageAdap"
},
{
"path": "dist/packages/fs-storage/types/loki/src/operator_packages.d.ts",
"chars": 4075,
"preview": "import { ILokiComparer } from \"./comparators\";\n/** Hash interface for named LokiOperatorPackage registration */\nexport i"
},
{
"path": "dist/packages/fs-storage/types/loki/src/ranged_indexes.d.ts",
"chars": 954,
"preview": "import { ILokiComparer } from \"./comparators\";\nexport declare type RangedValueOperator = \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\""
},
{
"path": "dist/packages/fs-storage/types/loki/src/result_set.d.ts",
"chars": 12963,
"preview": "import { Collection } from \"./collection\";\nimport { CloneMethod } from \"./clone\";\nimport { Doc } from \"../../common/type"
},
{
"path": "dist/packages/fs-storage/types/loki/src/unique_index.d.ts",
"chars": 1057,
"preview": "export declare class UniqueIndex {\n private _field;\n private _lokiMap;\n private _valMap;\n /**\n * Constru"
},
{
"path": "dist/packages/fs-storage/types/memory-storage/src/index.d.ts",
"chars": 106,
"preview": "import { MemoryStorage } from \"./memory_storage\";\nexport { MemoryStorage };\nexport default MemoryStorage;\n"
},
{
"path": "dist/packages/fs-storage/types/memory-storage/src/memory_storage.d.ts",
"chars": 2107,
"preview": "import { Dict, StorageAdapter } from \"../../common/types\";\n/**\n * An in-memory persistence adapter for an in-memory data"
},
{
"path": "dist/packages/fs-storage/types/partitioning-adapter/src/index.d.ts",
"chars": 130,
"preview": "import { PartitioningAdapter } from \"./partitioning_adapter\";\nexport { PartitioningAdapter };\nexport default Partitionin"
},
{
"path": "dist/packages/fs-storage/types/partitioning-adapter/src/partitioning_adapter.d.ts",
"chars": 3707,
"preview": "import { Loki } from \"../../loki/src/loki\";\nimport { StorageAdapter } from \"../../common/types\";\n/**\n * An adapter for a"
},
{
"path": "dist/packages/full-text-search/lokidb.full-text-search.js",
"chars": 85046,
"preview": "(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object"
},
{
"path": "dist/packages/full-text-search/types/common/plugin.d.ts",
"chars": 55,
"preview": "/**\n * @hidden\n */\nexport declare const PLUGINS: void;\n"
},
{
"path": "dist/packages/full-text-search/types/common/types.d.ts",
"chars": 633,
"preview": "/**\n * @hidden\n */\nimport { Loki } from \"../loki/src/loki\";\nexport interface StorageAdapter {\n loadDatabase(dbname: s"
},
{
"path": "dist/packages/full-text-search/types/fs-storage/src/fs_storage.d.ts",
"chars": 1340,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists using node fs modu"
},
{
"path": "dist/packages/full-text-search/types/fs-storage/src/index.d.ts",
"chars": 90,
"preview": "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",
"chars": 1060,
"preview": "import { CharacterFilter } from \"./character_filter\";\nimport { Tokenizer, whitespaceTokenizer } from \"./tokenizer\";\nimpo"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/character_filter.d.ts",
"chars": 162,
"preview": "/**\n * A character filter is used to preprocess a string before it is passed to a tokenizer.\n */\nexport declare type Cha"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/token_filter.d.ts",
"chars": 567,
"preview": "/**\n * A token filter takes tokens from a tokenizer and modify, delete or add tokens.\n */\nexport declare type TokenFilte"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/analyzer/tokenizer.d.ts",
"chars": 333,
"preview": "/**\n * A tokenizer splits a string into individual tokens.\n */\nexport declare type Tokenizer = (value: string) => string"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/full_text_search.d.ts",
"chars": 1871,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/automaton.d.ts",
"chars": 896,
"preview": "/**\n * Transition with dest, min and max.\n * @hidden\n */\nexport declare type Transition = [number, number, number];\n/**\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev1TPara"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev2TPara"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts",
"chars": 544,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidde"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/long.d.ts",
"chars": 994,
"preview": "/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nexport declare "
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/parametric_description.d.ts",
"chars": 844,
"preview": "import { Long } from \"./long\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescripti"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/fuzzy/run_automaton.d.ts",
"chars": 406,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\ne"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/index.d.ts",
"chars": 414,
"preview": "import { FullTextSearch } from \"./full_text_search\";\nimport { analyze, StandardAnalyzer } from \"./analyzer/analyzer\";\nim"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/index_searcher.d.ts",
"chars": 779,
"preview": "import { Scorer } from \"./scorer\";\nimport { InvertedIndex } from \"./inverted_index\";\nimport { Query } from \"./query_type"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/inverted_index.d.ts",
"chars": 4586,
"preview": "import { Analyzer } from \"./analyzer/analyzer\";\n/**\n * Converts a string into an array of code points.\n * @param str - t"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/query_types.d.ts",
"chars": 3038,
"preview": "/**\n * Base query to enable boost to a query type.\n */\nexport interface BaseQuery<Type> {\n type: Type;\n boost?: nu"
},
{
"path": "dist/packages/full-text-search/types/full-text-search/src/scorer.d.ts",
"chars": 2028,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language/src/index.d.ts",
"chars": 94,
"preview": "export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from \"./language\";\n"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language/src/language.d.ts",
"chars": 1367,
"preview": "export declare function generateTrimmer(wordCharacters: string): (token: string) => string;\nexport declare function gene"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-de/src/german_analyzer.d.ts",
"chars": 224,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class GermanAnalyzer implements "
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-de/src/index.d.ts",
"chars": 110,
"preview": "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",
"chars": 225,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class EnglishAnalyzer implements"
},
{
"path": "dist/packages/full-text-search/types/full-text-search-language-en/src/index.d.ts",
"chars": 114,
"preview": "import { EnglishAnalyzer } from \"./english_analyzer\";\nexport { EnglishAnalyzer };\nexport default EnglishAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search/types/indexed-storage/src/index.d.ts",
"chars": 110,
"preview": "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",
"chars": 3912,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * Loki persistence adapter class for indexedDb.\n * This cl"
},
{
"path": "dist/packages/full-text-search/types/local-storage/src/index.d.ts",
"chars": 102,
"preview": "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",
"chars": 1453,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists to web browser's l"
},
{
"path": "dist/packages/full-text-search/types/loki/src/avl_index.d.ts",
"chars": 5526,
"preview": "import { IRangedIndex, IRangedIndexRequest } from \"./ranged_indexes\";\nimport { ILokiComparer } from \"./comparators\";\n/**"
},
{
"path": "dist/packages/full-text-search/types/loki/src/clone.d.ts",
"chars": 181,
"preview": "export declare type CloneMethod = \"parse-stringify\" | \"deep\" | \"shallow\" | \"shallow-recurse\";\n/**\n * @hidden\n */\nexport "
},
{
"path": "dist/packages/full-text-search/types/loki/src/collection.d.ts",
"chars": 23653,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { UniqueIndex } from \"./unique_index\";\nimport { ResultSet } f"
},
{
"path": "dist/packages/full-text-search/types/loki/src/comparators.d.ts",
"chars": 1014,
"preview": "export interface ILokiComparer<T> {\n (a: T, b: T): -1 | 0 | 1;\n}\nexport interface IComparatorMap {\n [name: string]"
},
{
"path": "dist/packages/full-text-search/types/loki/src/dynamic_view.d.ts",
"chars": 12701,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { ResultSet } from \"./result_set\";\nimport { Collection } from"
},
{
"path": "dist/packages/full-text-search/types/loki/src/event_emitter.d.ts",
"chars": 2014,
"preview": "/**\n * LokiEventEmitter is a minimalist version of EventEmitter. It enables any\n * constructor that inherits EventEmitte"
},
{
"path": "dist/packages/full-text-search/types/loki/src/index.d.ts",
"chars": 124,
"preview": "import { Loki } from \"./loki\";\nimport { Collection } from \"./collection\";\nexport { Loki, Collection };\nexport default Lo"
},
{
"path": "dist/packages/full-text-search/types/loki/src/loki.d.ts",
"chars": 17959,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { Collection } from \"./collection\";\nimport { Doc, StorageAdap"
},
{
"path": "dist/packages/full-text-search/types/loki/src/operator_packages.d.ts",
"chars": 4075,
"preview": "import { ILokiComparer } from \"./comparators\";\n/** Hash interface for named LokiOperatorPackage registration */\nexport i"
},
{
"path": "dist/packages/full-text-search/types/loki/src/ranged_indexes.d.ts",
"chars": 954,
"preview": "import { ILokiComparer } from \"./comparators\";\nexport declare type RangedValueOperator = \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\""
},
{
"path": "dist/packages/full-text-search/types/loki/src/result_set.d.ts",
"chars": 12963,
"preview": "import { Collection } from \"./collection\";\nimport { CloneMethod } from \"./clone\";\nimport { Doc } from \"../../common/type"
},
{
"path": "dist/packages/full-text-search/types/loki/src/unique_index.d.ts",
"chars": 1057,
"preview": "export declare class UniqueIndex {\n private _field;\n private _lokiMap;\n private _valMap;\n /**\n * Constru"
},
{
"path": "dist/packages/full-text-search/types/memory-storage/src/index.d.ts",
"chars": 106,
"preview": "import { MemoryStorage } from \"./memory_storage\";\nexport { MemoryStorage };\nexport default MemoryStorage;\n"
},
{
"path": "dist/packages/full-text-search/types/memory-storage/src/memory_storage.d.ts",
"chars": 2107,
"preview": "import { Dict, StorageAdapter } from \"../../common/types\";\n/**\n * An in-memory persistence adapter for an in-memory data"
},
{
"path": "dist/packages/full-text-search/types/partitioning-adapter/src/index.d.ts",
"chars": 130,
"preview": "import { PartitioningAdapter } from \"./partitioning_adapter\";\nexport { PartitioningAdapter };\nexport default Partitionin"
},
{
"path": "dist/packages/full-text-search/types/partitioning-adapter/src/partitioning_adapter.d.ts",
"chars": 3707,
"preview": "import { Loki } from \"../../loki/src/loki\";\nimport { StorageAdapter } from \"../../common/types\";\n/**\n * An adapter for a"
},
{
"path": "dist/packages/full-text-search-language/lokidb.full-text-search-language.js",
"chars": 13564,
"preview": "(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object"
},
{
"path": "dist/packages/full-text-search-language/types/common/plugin.d.ts",
"chars": 55,
"preview": "/**\n * @hidden\n */\nexport declare const PLUGINS: void;\n"
},
{
"path": "dist/packages/full-text-search-language/types/common/types.d.ts",
"chars": 633,
"preview": "/**\n * @hidden\n */\nimport { Loki } from \"../loki/src/loki\";\nexport interface StorageAdapter {\n loadDatabase(dbname: s"
},
{
"path": "dist/packages/full-text-search-language/types/fs-storage/src/fs_storage.d.ts",
"chars": 1340,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists using node fs modu"
},
{
"path": "dist/packages/full-text-search-language/types/fs-storage/src/index.d.ts",
"chars": 90,
"preview": "import { FSStorage } from \"./fs_storage\";\nexport { FSStorage };\nexport default FSStorage;\n"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/analyzer/analyzer.d.ts",
"chars": 1060,
"preview": "import { CharacterFilter } from \"./character_filter\";\nimport { Tokenizer, whitespaceTokenizer } from \"./tokenizer\";\nimpo"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/analyzer/character_filter.d.ts",
"chars": 162,
"preview": "/**\n * A character filter is used to preprocess a string before it is passed to a tokenizer.\n */\nexport declare type Cha"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/analyzer/token_filter.d.ts",
"chars": 567,
"preview": "/**\n * A token filter takes tokens from a tokenizer and modify, delete or add tokens.\n */\nexport declare type TokenFilte"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/analyzer/tokenizer.d.ts",
"chars": 333,
"preview": "/**\n * A tokenizer splits a string into individual tokens.\n */\nexport declare type Tokenizer = (value: string) => string"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/full_text_search.d.ts",
"chars": 1871,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/automaton.d.ts",
"chars": 896,
"preview": "/**\n * Transition with dest, min and max.\n * @hidden\n */\nexport declare type Transition = [number, number, number];\n/**\n"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev1TPara"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev2TPara"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts",
"chars": 544,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidde"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/long.d.ts",
"chars": 994,
"preview": "/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nexport declare "
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/parametric_description.d.ts",
"chars": 844,
"preview": "import { Long } from \"./long\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescripti"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/fuzzy/run_automaton.d.ts",
"chars": 406,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\ne"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/index.d.ts",
"chars": 414,
"preview": "import { FullTextSearch } from \"./full_text_search\";\nimport { analyze, StandardAnalyzer } from \"./analyzer/analyzer\";\nim"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/index_searcher.d.ts",
"chars": 779,
"preview": "import { Scorer } from \"./scorer\";\nimport { InvertedIndex } from \"./inverted_index\";\nimport { Query } from \"./query_type"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/inverted_index.d.ts",
"chars": 4586,
"preview": "import { Analyzer } from \"./analyzer/analyzer\";\n/**\n * Converts a string into an array of code points.\n * @param str - t"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/query_types.d.ts",
"chars": 3038,
"preview": "/**\n * Base query to enable boost to a query type.\n */\nexport interface BaseQuery<Type> {\n type: Type;\n boost?: nu"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search/src/scorer.d.ts",
"chars": 2028,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search-language/src/index.d.ts",
"chars": 94,
"preview": "export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from \"./language\";\n"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search-language/src/language.d.ts",
"chars": 1367,
"preview": "export declare function generateTrimmer(wordCharacters: string): (token: string) => string;\nexport declare function gene"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search-language-de/src/german_analyzer.d.ts",
"chars": 224,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class GermanAnalyzer implements "
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search-language-de/src/index.d.ts",
"chars": 110,
"preview": "import { GermanAnalyzer } from \"./german_analyzer\";\nexport { GermanAnalyzer };\nexport default GermanAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search-language-en/src/english_analyzer.d.ts",
"chars": 225,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class EnglishAnalyzer implements"
},
{
"path": "dist/packages/full-text-search-language/types/full-text-search-language-en/src/index.d.ts",
"chars": 114,
"preview": "import { EnglishAnalyzer } from \"./english_analyzer\";\nexport { EnglishAnalyzer };\nexport default EnglishAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search-language/types/indexed-storage/src/index.d.ts",
"chars": 110,
"preview": "import { IndexedStorage } from \"./indexed_storage\";\nexport { IndexedStorage };\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/full-text-search-language/types/indexed-storage/src/indexed_storage.d.ts",
"chars": 3912,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * Loki persistence adapter class for indexedDb.\n * This cl"
},
{
"path": "dist/packages/full-text-search-language/types/local-storage/src/index.d.ts",
"chars": 102,
"preview": "import { LocalStorage } from \"./local_storage\";\nexport { LocalStorage };\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/full-text-search-language/types/local-storage/src/local_storage.d.ts",
"chars": 1453,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists to web browser's l"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/avl_index.d.ts",
"chars": 5526,
"preview": "import { IRangedIndex, IRangedIndexRequest } from \"./ranged_indexes\";\nimport { ILokiComparer } from \"./comparators\";\n/**"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/clone.d.ts",
"chars": 181,
"preview": "export declare type CloneMethod = \"parse-stringify\" | \"deep\" | \"shallow\" | \"shallow-recurse\";\n/**\n * @hidden\n */\nexport "
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/collection.d.ts",
"chars": 23653,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { UniqueIndex } from \"./unique_index\";\nimport { ResultSet } f"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/comparators.d.ts",
"chars": 1014,
"preview": "export interface ILokiComparer<T> {\n (a: T, b: T): -1 | 0 | 1;\n}\nexport interface IComparatorMap {\n [name: string]"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/dynamic_view.d.ts",
"chars": 12701,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { ResultSet } from \"./result_set\";\nimport { Collection } from"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/event_emitter.d.ts",
"chars": 2014,
"preview": "/**\n * LokiEventEmitter is a minimalist version of EventEmitter. It enables any\n * constructor that inherits EventEmitte"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/index.d.ts",
"chars": 124,
"preview": "import { Loki } from \"./loki\";\nimport { Collection } from \"./collection\";\nexport { Loki, Collection };\nexport default Lo"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/loki.d.ts",
"chars": 17959,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { Collection } from \"./collection\";\nimport { Doc, StorageAdap"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/operator_packages.d.ts",
"chars": 4075,
"preview": "import { ILokiComparer } from \"./comparators\";\n/** Hash interface for named LokiOperatorPackage registration */\nexport i"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/ranged_indexes.d.ts",
"chars": 954,
"preview": "import { ILokiComparer } from \"./comparators\";\nexport declare type RangedValueOperator = \"$gt\" | \"$gte\" | \"$lt\" | \"$lte\""
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/result_set.d.ts",
"chars": 12963,
"preview": "import { Collection } from \"./collection\";\nimport { CloneMethod } from \"./clone\";\nimport { Doc } from \"../../common/type"
},
{
"path": "dist/packages/full-text-search-language/types/loki/src/unique_index.d.ts",
"chars": 1057,
"preview": "export declare class UniqueIndex {\n private _field;\n private _lokiMap;\n private _valMap;\n /**\n * Constru"
},
{
"path": "dist/packages/full-text-search-language/types/memory-storage/src/index.d.ts",
"chars": 106,
"preview": "import { MemoryStorage } from \"./memory_storage\";\nexport { MemoryStorage };\nexport default MemoryStorage;\n"
},
{
"path": "dist/packages/full-text-search-language/types/memory-storage/src/memory_storage.d.ts",
"chars": 2107,
"preview": "import { Dict, StorageAdapter } from \"../../common/types\";\n/**\n * An in-memory persistence adapter for an in-memory data"
},
{
"path": "dist/packages/full-text-search-language/types/partitioning-adapter/src/index.d.ts",
"chars": 130,
"preview": "import { PartitioningAdapter } from \"./partitioning_adapter\";\nexport { PartitioningAdapter };\nexport default Partitionin"
},
{
"path": "dist/packages/full-text-search-language/types/partitioning-adapter/src/partitioning_adapter.d.ts",
"chars": 3707,
"preview": "import { Loki } from \"../../loki/src/loki\";\nimport { StorageAdapter } from \"../../common/types\";\n/**\n * An adapter for a"
},
{
"path": "dist/packages/full-text-search-language-de/lokidb.full-text-search-language-de.js",
"chars": 19290,
"preview": "(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object"
},
{
"path": "dist/packages/full-text-search-language-de/types/common/plugin.d.ts",
"chars": 55,
"preview": "/**\n * @hidden\n */\nexport declare const PLUGINS: void;\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/common/types.d.ts",
"chars": 633,
"preview": "/**\n * @hidden\n */\nimport { Loki } from \"../loki/src/loki\";\nexport interface StorageAdapter {\n loadDatabase(dbname: s"
},
{
"path": "dist/packages/full-text-search-language-de/types/fs-storage/src/fs_storage.d.ts",
"chars": 1340,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists using node fs modu"
},
{
"path": "dist/packages/full-text-search-language-de/types/fs-storage/src/index.d.ts",
"chars": 90,
"preview": "import { FSStorage } from \"./fs_storage\";\nexport { FSStorage };\nexport default FSStorage;\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/analyzer.d.ts",
"chars": 1060,
"preview": "import { CharacterFilter } from \"./character_filter\";\nimport { Tokenizer, whitespaceTokenizer } from \"./tokenizer\";\nimpo"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/character_filter.d.ts",
"chars": 162,
"preview": "/**\n * A character filter is used to preprocess a string before it is passed to a tokenizer.\n */\nexport declare type Cha"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/token_filter.d.ts",
"chars": 567,
"preview": "/**\n * A token filter takes tokens from a tokenizer and modify, delete or add tokens.\n */\nexport declare type TokenFilte"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/analyzer/tokenizer.d.ts",
"chars": 333,
"preview": "/**\n * A tokenizer splits a string into individual tokens.\n */\nexport declare type Tokenizer = (value: string) => string"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/full_text_search.d.ts",
"chars": 1871,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/automaton.d.ts",
"chars": 896,
"preview": "/**\n * Transition with dest, min and max.\n * @hidden\n */\nexport declare type Transition = [number, number, number];\n/**\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/lev1t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev1TPara"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/lev2t_parametric_description.d.ts",
"chars": 344,
"preview": "import { ParametricDescription } from \"./parametric_description\";\n/**\n * From org/apache/lucene/util/automaton/Lev2TPara"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/levenshtein_automata.d.ts",
"chars": 544,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java\n * @hidde"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/long.d.ts",
"chars": 994,
"preview": "/**\n * Class supports 64Bit integer operations.\n * A cut-down version of dcodeIO/long.js.\n * @hidden\n */\nexport declare "
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/parametric_description.d.ts",
"chars": 844,
"preview": "import { Long } from \"./long\";\n/**\n * From org/apache/lucene/util/automaton/LevenshteinAutomata.java#ParametricDescripti"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/fuzzy/run_automaton.d.ts",
"chars": 406,
"preview": "import { Automaton } from \"./automaton\";\n/**\n * From org/apache/lucene/util/automaton/RunAutomaton.java\n * @hidden\n */\ne"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/index.d.ts",
"chars": 414,
"preview": "import { FullTextSearch } from \"./full_text_search\";\nimport { analyze, StandardAnalyzer } from \"./analyzer/analyzer\";\nim"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/index_searcher.d.ts",
"chars": 779,
"preview": "import { Scorer } from \"./scorer\";\nimport { InvertedIndex } from \"./inverted_index\";\nimport { Query } from \"./query_type"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/inverted_index.d.ts",
"chars": 4586,
"preview": "import { Analyzer } from \"./analyzer/analyzer\";\n/**\n * Converts a string into an array of code points.\n * @param str - t"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/query_types.d.ts",
"chars": 3038,
"preview": "/**\n * Base query to enable boost to a query type.\n */\nexport interface BaseQuery<Type> {\n type: Type;\n boost?: nu"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search/src/scorer.d.ts",
"chars": 2028,
"preview": "import { InvertedIndex } from \"./inverted_index\";\nimport { Dict } from \"../../common/types\";\nimport { Query } from \"./qu"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search-language/src/index.d.ts",
"chars": 94,
"preview": "export { generateStopWordFilter, generateTrimmer, Among, SnowballProgram } from \"./language\";\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search-language/src/language.d.ts",
"chars": 1367,
"preview": "export declare function generateTrimmer(wordCharacters: string): (token: string) => string;\nexport declare function gene"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search-language-de/src/german_analyzer.d.ts",
"chars": 224,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class GermanAnalyzer implements "
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search-language-de/src/index.d.ts",
"chars": 110,
"preview": "import { GermanAnalyzer } from \"./german_analyzer\";\nexport { GermanAnalyzer };\nexport default GermanAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search-language-en/src/english_analyzer.d.ts",
"chars": 225,
"preview": "import { Analyzer } from \"../../full-text-search/src/analyzer/analyzer\";\nexport declare class EnglishAnalyzer implements"
},
{
"path": "dist/packages/full-text-search-language-de/types/full-text-search-language-en/src/index.d.ts",
"chars": 114,
"preview": "import { EnglishAnalyzer } from \"./english_analyzer\";\nexport { EnglishAnalyzer };\nexport default EnglishAnalyzer;\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/indexed-storage/src/index.d.ts",
"chars": 110,
"preview": "import { IndexedStorage } from \"./indexed_storage\";\nexport { IndexedStorage };\nexport default IndexedStorage;\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/indexed-storage/src/indexed_storage.d.ts",
"chars": 3912,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * Loki persistence adapter class for indexedDb.\n * This cl"
},
{
"path": "dist/packages/full-text-search-language-de/types/local-storage/src/index.d.ts",
"chars": 102,
"preview": "import { LocalStorage } from \"./local_storage\";\nexport { LocalStorage };\nexport default LocalStorage;\n"
},
{
"path": "dist/packages/full-text-search-language-de/types/local-storage/src/local_storage.d.ts",
"chars": 1453,
"preview": "import { StorageAdapter } from \"../../common/types\";\n/**\n * A loki persistence adapter which persists to web browser's l"
},
{
"path": "dist/packages/full-text-search-language-de/types/loki/src/avl_index.d.ts",
"chars": 5526,
"preview": "import { IRangedIndex, IRangedIndexRequest } from \"./ranged_indexes\";\nimport { ILokiComparer } from \"./comparators\";\n/**"
},
{
"path": "dist/packages/full-text-search-language-de/types/loki/src/clone.d.ts",
"chars": 181,
"preview": "export declare type CloneMethod = \"parse-stringify\" | \"deep\" | \"shallow\" | \"shallow-recurse\";\n/**\n * @hidden\n */\nexport "
},
{
"path": "dist/packages/full-text-search-language-de/types/loki/src/collection.d.ts",
"chars": 23653,
"preview": "import { LokiEventEmitter } from \"./event_emitter\";\nimport { UniqueIndex } from \"./unique_index\";\nimport { ResultSet } f"
}
]
// ... and 443 more files (download for full content)
About this extraction
This page contains the full source code of the LokiJS-Forge/LokiDB GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 643 files (2.7 MB), approximately 755.6k tokens, and a symbol index with 2799 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.