fuse.js

constructor

public constructor(
    list: readonly T[],
    options?: IFuseOptions<T>,
    index?: FuseIndex<T>
);

property config

static config: Required<IFuseOptions<any>>;

property version

static version: string;

• Return the current version.

method add

add: (doc: T) => void;

• Adds a doc to the end the list.

method createIndex

static createIndex: <U>(
    keys: Array<FuseOptionKey<U>>,
    list: ReadonlyArray<U>,
    options?: FuseIndexOptions<U>
) => FuseIndex<U>;

• Use this method to pre-generate the index from the list, and pass it directly into the Fuse instance.

  _Note that Fuse will automatically index the table if one isn't provided during instantiation._

  const list: MyType[] = [myType1, myType2, etc...]
  
  const index = Fuse.createIndex<MyType>(
   keys: ['key1', 'key2']
   list: list
  )
  
  const options: Fuse.IFuseOptions<MyType> = {
   keys: ['key1', 'key2']
  }
  
  const myFuse = new Fuse(list, options, index)

  Parameter keys

  The keys to index

  Parameter list

  The list from which to create an index

  Parameter options

  ?

  Returns

  An indexed list

method getIndex

getIndex: () => FuseIndex<T>;

• Returns the generated Fuse index

method parseIndex

static parseIndex: <U>(
    index: { keys: ReadonlyArray<string>; records: FuseIndexRecords },
    options?: FuseIndexOptions<U>
) => FuseIndex<U>;

method remove

remove: (predicate: (doc: T, idx: number) => boolean) => T[];

• Removes all documents from the list which the predicate returns truthy for, and returns an array of the removed docs. The predicate is invoked with two arguments: (doc, index).

method removeAt

removeAt: (idx: number) => void;

• Removes the doc at the specified index.

method search

search: <R = T>(
    pattern: string | Expression,
    options?: FuseSearchOptions
) => FuseResult<R>[];

• Search function for the Fuse instance.

  const list: MyType[] = [myType1, myType2, etc...]
  
  const options: Fuse.IFuseOptions<MyType> = {
   keys: ['key1', 'key2']
  }
  
  const myFuse = new Fuse(list, options)
  let result = myFuse.search('pattern')

  Parameter pattern

  The pattern to search

  Parameter options

  Fuse.FuseSearchOptions

  Returns

  An array of search results

method setCollection

setCollection: (docs: ReadonlyArray<T>, index?: FuseIndex<T>) => void;

constructor

public constructor(options?: FuseIndexOptions<T>);

method add

add: (doc: T) => void;

method create

create: () => void;

method setIndexRecords

setIndexRecords: (records: FuseIndexRecords) => void;

method setKeys

setKeys: (keys: ReadonlyArray<string>) => void;

method setSources

setSources: (docs: ReadonlyArray<T>) => void;

method toJSON

toJSON: () => { keys: ReadonlyArray<string>; records: FuseIndexRecords };

property distance

distance?: number;

• Determines how close the match must be to the fuzzy location (specified by location). An exact letter match which is distance characters away from the fuzzy location would score as a complete mismatch. A distance of 0 requires the match be at the exact location specified. A distance of 1000 would require a perfect match to be within 800 characters of the location to be found using a threshold of 0.8.

property fieldNormWeight

fieldNormWeight?: number;

• Determines how much the field-length norm affects scoring. A value of 0 is equivalent to ignoring the field-length norm. A value of 0.5 will greatly reduce the effect of field-length norm, while a value of 2.0 will greatly increase it.

property findAllMatches

findAllMatches?: boolean;

• When true, the matching function will continue to the end of a search pattern even if a perfect match has already been located in the string.

property getFn

getFn?: FuseGetFunction<T>;

• The function to use to retrieve an object's value at the provided path. The default will also search nested paths.

property ignoreDiacritics

ignoreDiacritics?: boolean;

• Indicates whether comparisons should ignore diacritics (accents).

property ignoreFieldNorm

ignoreFieldNorm?: boolean;

• When true, the calculation for the relevance score (used for sorting) will ignore the field-length norm.

property ignoreLocation

ignoreLocation?: boolean;

• When true, search will ignore location and distance, so it won't matter where in the string the pattern appears.

property includeMatches

includeMatches?: boolean;

• Whether the matches should be included in the result set. When true, each record in the result set will include the indices of the matched characters. These can consequently be used for highlighting purposes.

property includeScore

includeScore?: boolean;

• Whether the score should be included in the result set. A score of 0indicates a perfect match, while a score of 1 indicates a complete mismatch.

property isCaseSensitive

isCaseSensitive?: boolean;

• Indicates whether comparisons should be case sensitive.

property keys

keys?: Array<FuseOptionKey<T>>;

• List of keys that will be searched. This supports nested paths, weighted search, searching in arrays of strings and objects.

property location

location?: number;

• Determines approximately where in the text is the pattern expected to be found.

property minMatchCharLength

minMatchCharLength?: number;

• Only the matches whose length exceeds this value will be returned. (For instance, if you want to ignore single character matches in the result, set it to 2).

property shouldSort

shouldSort?: boolean;

• Whether to sort the result list, by score.

property sortFn

sortFn?: FuseSortFunction;

• The function to use to sort all the results. The default will sort by ascending relevance score, ascending index.

property threshold

threshold?: number;

• At what point does the match algorithm give up. A threshold of 0.0 requires a perfect match (of both letters and location), a threshold of 1.0 would match anything.

property useExtendedSearch

useExtendedSearch?: boolean;

• When true, it enables the use of unix-like search commands. See [example](/examples.html#extended-search).