Fuse.search doesn't return only T[]

Current TS definition says,

search(pattern: string): T[]

But with includeScore, the search returns: search(pattern: string): T[] | { item: T, score: number }[];

For now, I am ignoring the return type with // @ts-ignore.

[william-lohan]

There is more:

with id search(pattern: string): string[];

with includeMatches search(pattern: string): { item: T; matches: any; }[];

with id and includeMatches search(pattern: string): { item: string; matches: any; }[];

its really ugly but modifying the definition file like this seems to work

export = Fuse;
export as namespace Fuse;

declare class Fuse<T, O extends Fuse.FuseOptions<T> = Fuse.FuseOptions<T>> {
  constructor(list: ReadonlyArray<T>, options?: O)
  search(pattern: string): O extends { id: keyof T } ?
    O extends ({ includeMatches: true; } | { includeScore: true; }) ? Fuse.FuseResult<string>[] : string[] :
    O extends ({ includeMatches: true; } | { includeScore: true; }) ? Fuse.FuseResult<T>[] : T[];

  setCollection(list: ReadonlyArray<T>): ReadonlyArray<T>;
}

declare namespace Fuse {
  export interface FuseResult<T> {
    item: T,
    matches?: any;
    score?: number;
  }
  export interface FuseOptions<T> {
    id?: keyof T;
    caseSensitive?: boolean;
    includeMatches?: boolean;
    includeScore?: boolean;
    shouldSort?: boolean;
    sortFn?: (a: { score: number }, b: { score: number }) => number;
    getFn?: (obj: any, path: string) => any;
    keys?: (keyof T)[] | { name: keyof T; weight: number }[];
    verbose?: boolean;
    tokenize?: boolean;
    tokenSeparator?: RegExp;
    matchAllTokens?: boolean;
    location?: number;
    distance?: number;
    threshold?: number;
    maxPatternLength?: number;
    minMatchCharLength?: number;
    findAllMatches?: boolean;
  }
}

[zhouzi]

@william-lohan thank you! 👍 Following your example, I got it working like so:

interface User {
  email: string;
}
const users: User[] = [
  {
    email: '[e-mail]'
  },
  {
    email: '[e-mail]'
  }
];
const matchingUsers: User[] =
  new Fuse(users, {
    includeScore: true,
    shouldSort: false,
    keys: ['email']
  })
    .search('jane')
    .map(result => result.item);

There are two important limitations: Fuse.FuseOptions cannot be used and the options object has to be inlined. For example, the following doesn’t work:

interface User {
  email: string;
}
const users: User[] = [
  {
    email: '[e-mail]'
  },
  {
    email: '[e-mail]'
  }
];
const FUSE_OPTIONS = {
  includeScore: true,
  shouldSort: false,
  keys: ['email']
};
const matchingUsers: User[] =
  new Fuse(users, FUSE_OPTIONS)
    .search('jane')
    .map(result => result.item);

Anyway, I believe the initial issue has been fixed and can be closed.