This commit is contained in:
253
node_modules/minisearch/dist/cjs/SearchableMap.d.cts
generated
vendored
Normal file
253
node_modules/minisearch/dist/cjs/SearchableMap.d.cts
generated
vendored
Normal file
@@ -0,0 +1,253 @@
|
||||
type LeafType = '' & {
|
||||
readonly __tag: unique symbol;
|
||||
};
|
||||
interface RadixTree<T> extends Map<string, T | RadixTree<T>> {
|
||||
get(key: LeafType): T | undefined;
|
||||
get(key: string): RadixTree<T> | undefined;
|
||||
set(key: LeafType, value: T): this;
|
||||
set(key: string, value: RadixTree<T>): this;
|
||||
}
|
||||
type Entry<T> = [string, T];
|
||||
|
||||
interface Iterators<T> {
|
||||
ENTRIES: Entry<T>;
|
||||
KEYS: string;
|
||||
VALUES: T;
|
||||
}
|
||||
type Kind<T> = keyof Iterators<T>;
|
||||
type Result<T, K extends keyof Iterators<T>> = Iterators<T>[K];
|
||||
type IteratorPath<T> = {
|
||||
node: RadixTree<T>;
|
||||
keys: string[];
|
||||
}[];
|
||||
type IterableSet<T> = {
|
||||
_tree: RadixTree<T>;
|
||||
_prefix: string;
|
||||
};
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
declare class TreeIterator<T, K extends Kind<T>> implements Iterator<Result<T, K>> {
|
||||
set: IterableSet<T>;
|
||||
_type: K;
|
||||
_path: IteratorPath<T>;
|
||||
constructor(set: IterableSet<T>, type: K);
|
||||
next(): IteratorResult<Result<T, K>>;
|
||||
dive(): IteratorResult<Result<T, K>>;
|
||||
backtrack(): void;
|
||||
key(): string;
|
||||
value(): T;
|
||||
result(): Result<T, K>;
|
||||
[Symbol.iterator](): this;
|
||||
}
|
||||
|
||||
type FuzzyResult<T> = [T, number];
|
||||
type FuzzyResults<T> = Map<string, FuzzyResult<T>>;
|
||||
|
||||
/**
|
||||
* A class implementing the same interface as a standard JavaScript
|
||||
* [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
|
||||
* with string keys, but adding support for efficiently searching entries with
|
||||
* prefix or fuzzy search. This class is used internally by {@link MiniSearch}
|
||||
* as the inverted index data structure. The implementation is a radix tree
|
||||
* (compressed prefix tree).
|
||||
*
|
||||
* Since this class can be of general utility beyond _MiniSearch_, it is
|
||||
* exported by the `minisearch` package and can be imported (or required) as
|
||||
* `minisearch/SearchableMap`.
|
||||
*
|
||||
* @typeParam T The type of the values stored in the map.
|
||||
*/
|
||||
declare class SearchableMap<T = any> {
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
_tree: RadixTree<T>;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
_prefix: string;
|
||||
private _size;
|
||||
/**
|
||||
* The constructor is normally called without arguments, creating an empty
|
||||
* map. In order to create a {@link SearchableMap} from an iterable or from an
|
||||
* object, check {@link SearchableMap.from} and {@link
|
||||
* SearchableMap.fromObject}.
|
||||
*
|
||||
* The constructor arguments are for internal use, when creating derived
|
||||
* mutable views of a map at a prefix.
|
||||
*/
|
||||
constructor(tree?: RadixTree<T>, prefix?: string);
|
||||
/**
|
||||
* Creates and returns a mutable view of this {@link SearchableMap},
|
||||
* containing only entries that share the given prefix.
|
||||
*
|
||||
* ### Usage:
|
||||
*
|
||||
* ```javascript
|
||||
* let map = new SearchableMap()
|
||||
* map.set("unicorn", 1)
|
||||
* map.set("universe", 2)
|
||||
* map.set("university", 3)
|
||||
* map.set("unique", 4)
|
||||
* map.set("hello", 5)
|
||||
*
|
||||
* let uni = map.atPrefix("uni")
|
||||
* uni.get("unique") // => 4
|
||||
* uni.get("unicorn") // => 1
|
||||
* uni.get("hello") // => undefined
|
||||
*
|
||||
* let univer = map.atPrefix("univer")
|
||||
* univer.get("unique") // => undefined
|
||||
* univer.get("universe") // => 2
|
||||
* univer.get("university") // => 3
|
||||
* ```
|
||||
*
|
||||
* @param prefix The prefix
|
||||
* @return A {@link SearchableMap} representing a mutable view of the original
|
||||
* Map at the given prefix
|
||||
*/
|
||||
atPrefix(prefix: string): SearchableMap<T>;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
|
||||
*/
|
||||
clear(): void;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
|
||||
* @param key Key to delete
|
||||
*/
|
||||
delete(key: string): void;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
|
||||
* @return An iterator iterating through `[key, value]` entries.
|
||||
*/
|
||||
entries(): TreeIterator<T, "ENTRIES">;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
|
||||
* @param fn Iteration function
|
||||
*/
|
||||
forEach(fn: (key: string, value: T, map: SearchableMap) => void): void;
|
||||
/**
|
||||
* Returns a Map of all the entries that have a key within the given edit
|
||||
* distance from the search key. The keys of the returned Map are the matching
|
||||
* keys, while the values are two-element arrays where the first element is
|
||||
* the value associated to the key, and the second is the edit distance of the
|
||||
* key to the search key.
|
||||
*
|
||||
* ### Usage:
|
||||
*
|
||||
* ```javascript
|
||||
* let map = new SearchableMap()
|
||||
* map.set('hello', 'world')
|
||||
* map.set('hell', 'yeah')
|
||||
* map.set('ciao', 'mondo')
|
||||
*
|
||||
* // Get all entries that match the key 'hallo' with a maximum edit distance of 2
|
||||
* map.fuzzyGet('hallo', 2)
|
||||
* // => Map(2) { 'hello' => ['world', 1], 'hell' => ['yeah', 2] }
|
||||
*
|
||||
* // In the example, the "hello" key has value "world" and edit distance of 1
|
||||
* // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
|
||||
* // (change "e" to "a", delete "o")
|
||||
* ```
|
||||
*
|
||||
* @param key The search key
|
||||
* @param maxEditDistance The maximum edit distance (Levenshtein)
|
||||
* @return A Map of the matching keys to their value and edit distance
|
||||
*/
|
||||
fuzzyGet(key: string, maxEditDistance: number): FuzzyResults<T>;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
|
||||
* @param key Key to get
|
||||
* @return Value associated to the key, or `undefined` if the key is not
|
||||
* found.
|
||||
*/
|
||||
get(key: string): T | undefined;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
|
||||
* @param key Key
|
||||
* @return True if the key is in the map, false otherwise
|
||||
*/
|
||||
has(key: string): boolean;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
|
||||
* @return An `Iterable` iterating through keys
|
||||
*/
|
||||
keys(): TreeIterator<T, "KEYS">;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
|
||||
* @param key Key to set
|
||||
* @param value Value to associate to the key
|
||||
* @return The {@link SearchableMap} itself, to allow chaining
|
||||
*/
|
||||
set(key: string, value: T): SearchableMap<T>;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
|
||||
*/
|
||||
get size(): number;
|
||||
/**
|
||||
* Updates the value at the given key using the provided function. The function
|
||||
* is called with the current value at the key, and its return value is used as
|
||||
* the new value to be set.
|
||||
*
|
||||
* ### Example:
|
||||
*
|
||||
* ```javascript
|
||||
* // Increment the current value by one
|
||||
* searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
|
||||
* ```
|
||||
*
|
||||
* If the value at the given key is or will be an object, it might not require
|
||||
* re-assignment. In that case it is better to use `fetch()`, because it is
|
||||
* faster.
|
||||
*
|
||||
* @param key The key to update
|
||||
* @param fn The function used to compute the new value from the current one
|
||||
* @return The {@link SearchableMap} itself, to allow chaining
|
||||
*/
|
||||
update(key: string, fn: (value: T | undefined) => T): SearchableMap<T>;
|
||||
/**
|
||||
* Fetches the value of the given key. If the value does not exist, calls the
|
||||
* given function to create a new value, which is inserted at the given key
|
||||
* and subsequently returned.
|
||||
*
|
||||
* ### Example:
|
||||
*
|
||||
* ```javascript
|
||||
* const map = searchableMap.fetch('somekey', () => new Map())
|
||||
* map.set('foo', 'bar')
|
||||
* ```
|
||||
*
|
||||
* @param key The key to update
|
||||
* @param initial A function that creates a new value if the key does not exist
|
||||
* @return The existing or new value at the given key
|
||||
*/
|
||||
fetch(key: string, initial: () => T): T;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
|
||||
* @return An `Iterable` iterating through values.
|
||||
*/
|
||||
values(): TreeIterator<T, "VALUES">;
|
||||
/**
|
||||
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
|
||||
*/
|
||||
[Symbol.iterator](): TreeIterator<T, "ENTRIES">;
|
||||
/**
|
||||
* Creates a {@link SearchableMap} from an `Iterable` of entries
|
||||
*
|
||||
* @param entries Entries to be inserted in the {@link SearchableMap}
|
||||
* @return A new {@link SearchableMap} with the given entries
|
||||
*/
|
||||
static from<T = any>(entries: Iterable<Entry<T>> | Entry<T>[]): SearchableMap<any>;
|
||||
/**
|
||||
* Creates a {@link SearchableMap} from the iterable properties of a JavaScript object
|
||||
*
|
||||
* @param object Object of entries for the {@link SearchableMap}
|
||||
* @return A new {@link SearchableMap} with the given entries
|
||||
*/
|
||||
static fromObject<T = any>(object: {
|
||||
[key: string]: T;
|
||||
}): SearchableMap<any>;
|
||||
}
|
||||
|
||||
export { SearchableMap as default };
|
||||
Reference in New Issue
Block a user