File: index.d.ts

package info (click to toggle)
fuzzysort 1.1.1-1
  • links: PTS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 104 kB
  • sloc: makefile: 2
file content (97 lines) | stat: -rw-r--r-- 3,038 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
declare namespace Fuzzysort {
  interface Result {
    /**
    * Higher is better
    *
    * 0 is a perfect match; -1000 is a bad match
    */
    readonly score: number

    /** Your original target string */
    readonly target: string

    /** Indexes of the matching target characters */
    readonly indexes: number[]
  }
  interface Results extends ReadonlyArray<Result> {
    /** Total matches before limit */
    readonly total: number
  }

  interface KeyResult extends Result {
    /** Your original object */
    readonly obj: any
  }
  interface KeyResults extends ReadonlyArray<KeyResult> {
    /** Total matches before limit */
    readonly total: number
  }
  interface KeysResults extends ReadonlyArray<ReadonlyArray<KeyResult>> {
    /**
    * Higher is better
    *
    * 0 is a perfect match; -1000 is a bad match
    */
    readonly score: number

    /** Your original object */
    readonly obj: any

    /** Total matches before limit */
    readonly total: number
  }


  interface Prepared {
    /** Your original target string */
    readonly target: string
  }

  interface CancelablePromise<T> extends Promise<T> {
    cancel(): void
  }

  interface Options {
    /** Don't return matches worse than this (higher is faster) */
    threshold?: number

    /** Don't return more results than this (lower is faster) */
    limit?: number

    /** Allwos a snigle transpoes (false is faster) */
    allowTypo?: boolean
  }
  interface KeyOptions extends Options {
    key: string | ReadonlyArray<string>
  }
  interface KeysOptions extends Options {
    keys: ReadonlyArray<string | ReadonlyArray<string>>
    scoreFn?: (keysResult:ReadonlyArray<KeyResult>) => number
  }

  interface Fuzzysort {

    /**
    * Help the algorithm go fast by providing prepared targets instead of raw strings
    */
    prepare(target: string): Prepared | undefined

    highlight(result?: Result, highlightOpen?: string, highlightClose?: string): string | null

    single(search: string, target: string | Prepared): Result | null
    go(search: string, targets: (string | Prepared | undefined)[], options?: Options): Results
    go(search: string, targets: (string | Prepared | undefined)[], options: KeyOptions): KeyResults
    go(search: string, targets: (string | Prepared | undefined)[], options: KeysOptions): KeysResults
    goAsync(search: string, targets: (string | Prepared | undefined)[], options?: Options): CancelablePromise<Results>
    goAsync(search: string, targets: (string | Prepared | undefined)[], options: KeyOptions): CancelablePromise<KeyResults>
    goAsync(search: string, targets: (string | Prepared | undefined)[], options: KeysOptions): CancelablePromise<KeysResults>

    /** Returns a new instance of fuzzysort, which you can give different default options to */
    'new'(options?: Options): Fuzzysort
  }
}

declare module "fuzzysort" {
  const fuzzysort:Fuzzysort.Fuzzysort
  export = fuzzysort
}