Class CmpStrAsync<R>

The CmpStrAsync class provides a fully asynchronous API for string comparison, phonetic indexing, filtering and normalization.

Type Parameters

R = MetricRaw
The type of the metric result, defaults to MetricRaw

Hierarchy (View Summary)

CmpStr<R>
- CmpStrAsync

Index

Constructors

constructor

Properties

options clearCache filter metric phonetic profiler

Constructors

`Protected`constructor

new CmpStrAsync<R = MetricRaw>(opt?: string | CmpStrOptions): CmpStrAsync<R>
Creates a new CmpStrAsync instance calliing the super constructor.
Type Parameters
- R = MetricRaw
  The type of the metric result, defaults to MetricRaw
Parameters
- Optionalopt: string | CmpStrOptions
  Optional serialized or options object
Returns CmpStrAsync<R>
Overrides CmpStr.constructor
- Defined in CmpStrAsync.ts:73

Properties

`Protected`options

options: CmpStrOptions = ...

`Static` `Readonly`clearCache

clearCache: {
    filter: () => void;
    metric: () => void;
    normalizer: () => void;
    phonetic: () => void;
} = ...

Clears the caches for normalizer, filter pipelines, metric, and phonetic modules.

Type Declaration

filter: () => void
metric: () => void
normalizer: () => void
phonetic: () => void

`Static` `Readonly`filter

filter: {
    add: (
        hook: FilterHooks,
        id: string,
        fn: FilterFn,
        opt?: FilterOptions,
    ) => boolean;
    clear: (hook?: FilterHooks) => void;
    has: (hook: FilterHooks, id: string) => boolean;
    list: (hook: FilterHooks, active?: boolean) => string[];
    pause: (hook: FilterHooks, id: string) => boolean;
    remove: (hook: FilterHooks, id: string) => boolean;
    resume: (hook: FilterHooks, id: string) => boolean;
} = ...

Adds, removes, pauses, resumes, lists, or clears global filters.

Type Declaration

add: (hook: FilterHooks, id: string, fn: FilterFn, opt?: FilterOptions) => boolean
clear: (hook?: FilterHooks) => void
has: (hook: FilterHooks, id: string) => boolean
list: (hook: FilterHooks, active?: boolean) => string[]
pause: (hook: FilterHooks, id: string) => boolean
remove: (hook: FilterHooks, id: string) => boolean
resume: (hook: FilterHooks, id: string) => boolean

See

Filter

`Static` `Readonly`metric

metric: {
    add: (
        name: string,
        cls: RegistryConstructor<Metric<MetricRaw>>,
        update?: boolean,
    ) => void;
    has: (name: string) => boolean;
    list: () => string[];
    remove: (name: string) => void;
} = ...

Adds, removes, checks, or lists available metrics.

See

MetricRegistry

`Static` `Readonly`phonetic

phonetic: {
    add: (
        name: string,
        cls: RegistryConstructor<Phonetic>,
        update?: boolean,
    ) => void;
    has: (name: string) => boolean;
    list: () => string[];
    map: {
        add: (
            algo: string,
            id: string,
            map: PhoneticMap,
            update?: boolean,
        ) => void;
        has: (algo: string, id: string) => boolean;
        list: (algo: string) => string[];
        remove: (algo: string, id: string) => void;
    };
    remove: (name: string) => void;
} = ...

Adds, removes, checks, or lists available phonetic algorithms and mappings.

See

PhoneticRegistry

`Static` `Readonly`profiler

profiler: ProfilerService<any> = profiler.services

Provides access to the global profiler services.

See

Profiler

Methods

`Protected`assert

assert(cond: string, test?: any): void
Assert a condition and throws if the condition is not met.
Parameters
- cond: string
  The condition to met
- Optionaltest: any
  Value to test for
Returns void
Throws
If the condition is not met
Inherited from CmpStr.assert
- Defined in CmpStr.ts:193

`Protected`assertMany

assertMany(...cond: [string, any?][]): void
Assert multiple conditions.
Parameters
- ...cond: [string, any?][]
  Array of [ condition, value ] pairs
Returns void
Inherited from CmpStr.assertMany
- Defined in CmpStr.ts:215

batchSorted

batchSorted<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    dir?: "desc" | "asc",
    opt?: CmpStrOptions,
): T
Performs a batch metric comparison and returns results sorted by score.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionaldir: "desc" | "asc" = 'desc'
  Sort direction (desc, asc)
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The sorted batch results
Inherited from CmpStr.batchSorted
- Defined in CmpStr.ts:591

batchSortedAsync

batchSortedAsync<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    dir?: "desc" | "asc",
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously performs a batch metric comparison and returns results sorted by score.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionaldir: "desc" | "asc" = 'desc'
  Sort direction (desc, asc)
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The sorted batch results
- Defined in CmpStrAsync.ts:257

batchTest

batchTest<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    opt?: CmpStrOptions,
): T
Performs a batch metric comparison between source and target strings or array of strings.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The batch metric results
Inherited from CmpStr.batchTest
- Defined in CmpStr.ts:575

batchTestAsync

batchTestAsync<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously performs a batch metric comparison between source and target strings or array of strings.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The batch metric results
- Defined in CmpStrAsync.ts:241

clone

clone(): CmpStr<R>
Creates a shallow clone of the current instance.

Returns CmpStr<R>
- The cloned instance
Inherited from CmpStr.clone
- Defined in CmpStr.ts:395

closest

closest<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    n?: number,
    opt?: CmpStrOptions,
): T
Returns the n closest matches from a batch comparison.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionaln: number = 1
  Number of closest matches
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The closest matches
Inherited from CmpStr.closest
- Defined in CmpStr.ts:650

closestAsync

closestAsync<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    n?: number,
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously returns the n closest matches from a batch comparison.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionaln: number = 1
  Number of closest matches
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The closest matches
- Defined in CmpStrAsync.ts:318

compare

compare(a: string, b: string, opt?: CmpStrOptions): number
Performs a single metric comparison and returns only the numeric score.
Parameters
- a: string
  The source string
- b: string
  The target string
- Optionalopt: CmpStrOptions
  Optional options
Returns number
- The similarity score (0..1)
Inherited from CmpStr.compare
- Defined in CmpStr.ts:561

compareAsync

compareAsync(a: string, b: string, opt?: CmpStrOptions): Promise<number>
Asynchronously performs a single metric comparison returning the numeric score.
Parameters
- a: string
  The source string
- b: string
  The target string
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<number>
- The similarity score (0..1)
- Defined in CmpStrAsync.ts:227

`Protected`compute

compute<T extends CmpStrResult | CmpStrResult[] | MetricResult<R>>(
    a: MetricInput,
    b: MetricInput,
    opt?: CmpStrOptions,
    mode?: MetricMode,
    raw?: boolean,
    skip?: boolean,
): T
Computes the metric result for the given inputs, applying normalization and filtering as configured.
Type Parameters
- T extends CmpStrResult | CmpStrResult[] | MetricResult<R>
  The type of the metric result
Parameters
- a: MetricInput
  The first input string or array
- b: MetricInput
  The second input string or array
- Optionalopt: CmpStrOptions
  Optional options to use
- Optionalmode: MetricMode
  The metric mode to use
- Optionalraw: boolean
  Whether to return raw results
- Optionalskip: boolean
  Whether to skip normalization and filtering
Returns T
- The computed metric result
Inherited from CmpStr.compute
- Defined in CmpStr.ts:330

`Protected`computeAsync

computeAsync<T extends CmpStrResult | CmpStrResult[] | MetricResult<R>>(
    a: MetricInput,
    b: MetricInput,
    opt?: CmpStrOptions,
    mode?: MetricMode,
    raw?: boolean,
    skip?: boolean,
): Promise<T>
Asynchronously computes the metric result for the given inputs, applying normalization and filtering as configured.
Type Parameters
- T extends CmpStrResult | CmpStrResult[] | MetricResult<R>
  The type of the metric result
Parameters
- a: MetricInput
  The first input string or array
- b: MetricInput
  The second input string or array
- Optionalopt: CmpStrOptions
  Optional options to use
- Optionalmode: MetricMode
  The metric mode to use
- Optionalraw: boolean
  Whether to return raw results
- Optionalskip: boolean
  Whether to skip normalization and filtering
Returns Promise<T>
- The computed metric result
- Defined in CmpStrAsync.ts:161

`Protected`filter

filter(input: MetricInput, hook?: FilterHooks): MetricInput
Applies all active filters to the input string or array.
Parameters
- input: MetricInput
  The input string or array
- Optionalhook: FilterHooks
  The filter hook
Returns MetricInput
- The filtered string(s)
Inherited from CmpStr.filter
- Defined in CmpStr.ts:248

`Protected`filterAsync

filterAsync(input: MetricInput, hook?: FilterHooks): Promise<MetricInput>
Asynchronously applies all active filters to the input string or array.
Parameters
- input: MetricInput
  The input string or array
- Optionalhook: FilterHooks
  The filter hook
Returns Promise<MetricInput>
- The filtered string(s)
- Defined in CmpStrAsync.ts:102

furthest

furthest<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    n?: number,
    opt?: CmpStrOptions,
): T
Returns the n furthest matches from a batch comparison.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionaln: number = 1
  Number of furthest matches
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The furthest matches
Inherited from CmpStr.furthest
- Defined in CmpStr.ts:666

furthestAsync

furthestAsync<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    n?: number,
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously returns the n furthest matches from a batch comparison.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionaln: number = 1
  Number of furthest matches
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The furthest matches
- Defined in CmpStrAsync.ts:334

getOption

getOption(path: string): any
Returns a specific option value by path.
Parameters
- path: string
  The path to the option
Returns any
- The option value
Inherited from CmpStr.getOption
- Defined in CmpStr.ts:529

getOptions

getOptions(): CmpStrOptions
Returns the current options object.

Returns CmpStrOptions
- The options
Inherited from CmpStr.getOptions
- Defined in CmpStr.ts:514

getSerializedOptions

getSerializedOptions(): string
Returns the options as a JSON string.

Returns string
- The serialized options
Inherited from CmpStr.getSerializedOptions
- Defined in CmpStr.ts:521

`Protected`index

index(
input: MetricInput,
options: { algo: string; opt?: PhoneticOptions },
): MetricInput
Computes the phonetic index for the given input using the specified phonetic algorithm.
Parameters
- input: MetricInput
  The input string or array
- options: { algo: string; opt?: PhoneticOptions }
  The phonetic algorithm and options
Returns MetricInput
- The phonetic index for the given input
Inherited from CmpStr.index
- Defined in CmpStr.ts:294

`Protected`indexAsync

indexAsync(
input: MetricInput,
options: { algo: string; opt?: PhoneticOptions },
): Promise<MetricInput>
Asynchronously computes the phonetic index for the given input using the specified phonetic algorithm.
Parameters
- input: MetricInput
  The input string or array
- options: { algo: string; opt?: PhoneticOptions }
  The phonetic algorithm and options
Returns Promise<MetricInput>
- The phonetic index for the given input
- Defined in CmpStrAsync.ts:136

match

match<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    threshold: number,
    opt?: CmpStrOptions,
): T
Performs a batch comparison and returns only results above the threshold.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- threshold: number
  The similarity threshold (0..1)
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The filtered batch results
Inherited from CmpStr.match
- Defined in CmpStr.ts:630

matchAsync

matchAsync<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    threshold: number,
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously performs a batch comparison and returns only results above the threshold.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- threshold: number
  The similarity threshold (0..1)
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The filtered batch results
- Defined in CmpStrAsync.ts:297

matrix

matrix(input: string[], opt?: CmpStrOptions): number[][]
Computes a similarity matrix for the given input array.
Parameters
- input: string[]
  The input array
- Optionalopt: CmpStrOptions
  Optional options
Returns number[][]
- The similarity matrix
Inherited from CmpStr.matrix
- Defined in CmpStr.ts:701

matrixAsync

matrixAsync(input: string[], opt?: CmpStrOptions): Promise<number[][]>
Asynchronously computes a similarity matrix for the given input array.
Parameters
- input: string[]
  The input array
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<number[][]>
- The similarity matrix
- Defined in CmpStrAsync.ts:369

mergeOptions

mergeOptions(opt: CmpStrOptions): this
Deep merges and sets new options.
Parameters
- opt: CmpStrOptions
  The options to merge
Returns this
Inherited from CmpStr.mergeOptions
- Defined in CmpStr.ts:424

`Protected`normalize

normalize(input: MetricInput, flags?: string): MetricInput
Normalizes the input string or array using the configured or provided flags.
Parameters
- input: MetricInput
  The input string or array
- Optionalflags: string
  Normalization flags
Returns MetricInput
- The normalized input
Inherited from CmpStr.normalize
- Defined in CmpStr.ts:237

`Protected`normalizeAsync

normalizeAsync(input: MetricInput, flags?: string): Promise<MetricInput>
Asynchronously normalizes the input string or array using the configured or provided flags.
Parameters
- input: MetricInput
  The input string or array
- Optionalflags: string
  Normalization flags
Returns Promise<MetricInput>
- The normalized input
- Defined in CmpStrAsync.ts:91

`Protected`output

output<T extends CmpStrResult | CmpStrResult[] | MetricResult<R>>(
result: MetricResult<R>,
raw?: boolean,
): T
Resolves the result format (raw or formatted).
Type Parameters
- T extends CmpStrResult | CmpStrResult[] | MetricResult<R>
  The type of the metric result
Parameters
- result: MetricResult<R>
  The metric result
- Optionalraw: boolean
  Whether to return raw results
Returns T
- The resolved result
Inherited from CmpStr.output
- Defined in CmpStr.ts:372

pairs

pairs<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    opt?: CmpStrOptions,
): T
Performs a pairwise metric comparison between source and target strings or array of strings.

Input arrays needs of the same length to perform pairwise comparison, otherwise the method will throw an error.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The pairwise metric results
Inherited from CmpStr.pairs
- Defined in CmpStr.ts:614

pairsAsync

pairsAsync<T extends BatchResultLike<R> = any>(
    a: MetricInput,
    b: MetricInput,
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously performs a pairwise metric comparison between source and target strings or array of strings.

Input arrays needs of the same length to perform pairwise comparison, otherwise the method will throw an error.
Type Parameters
- T extends BatchResultLike<R> = any
  The type of the metric result
Parameters
- a: MetricInput
  The source string or array of strings
- b: MetricInput
  The target string or array of strings
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The pairwise metric results
- Defined in CmpStrAsync.ts:281

phoneticIndex

phoneticIndex(input?: string, algo?: string, opt?: PhoneticOptions): string
Computes the phonetic index for a string using the configured or given algorithm.
Parameters
- Optionalinput: string
  The input string
- Optionalalgo: string
  The phonetic algorithm to use
- Optionalopt: PhoneticOptions
  Optional phonetic options
Returns string
- The phonetic index as a string
Inherited from CmpStr.phoneticIndex
- Defined in CmpStr.ts:718

phoneticIndexAsync

phoneticIndexAsync(
    input?: string,
    algo?: string,
    opt?: PhoneticOptions,
): Promise<string>
Asynchronously computes the phonetic index for a string using the configured or given algorithm.
Parameters
- Optionalinput: string
  The input string
- Optionalalgo: string
  The phonetic algorithm to use
- Optionalopt: PhoneticOptions
  Optional phonetic options
Returns Promise<string>
- The phonetic index as a string
- Defined in CmpStrAsync.ts:388

`Protected`postProcess

postProcess(result: MetricResult<R>, opt?: CmpStrOptions): MetricResult<R>
Post-process the results of the metric computation.
Parameters
- result: MetricResult<R>
  The metric result
- Optionalopt: CmpStrOptions
Returns MetricResult<R>
- The post-processed results
Inherited from CmpStr.postProcess
- Defined in CmpStr.ts:280

`Protected`prepare

prepare(input?: MetricInput, opt?: CmpStrOptions): MetricInput
Prepares the input by normalizing and filtering.
Parameters
- Optionalinput: MetricInput
  The input string or array
- Optionalopt: CmpStrOptions
  Optional options to use
Returns MetricInput
- The prepared input
Inherited from CmpStr.prepare
- Defined in CmpStr.ts:259

`Protected`prepareAsync

prepareAsync(input?: MetricInput, opt?: CmpStrOptions): Promise<MetricInput>
Asynchronously prepares the input by normalizing and filtering.
Parameters
- Optionalinput: MetricInput
  The input string or array
- Optionalopt: CmpStrOptions
  Optional options to use
Returns Promise<MetricInput>
- The prepared input
- Defined in CmpStrAsync.ts:113

reset

reset(): this
Resets the instance, clearing all data and options.

Returns this
Inherited from CmpStr.reset
- Defined in CmpStr.ts:402

`Protected`resolveOptions

resolveOptions(opt?: CmpStrOptions): CmpStrOptions
Resolves the options for the CmpStr instance, merging the provided options with the existing options.
Parameters
- Optionalopt: CmpStrOptions
  Optional options to merge
Returns CmpStrOptions
- The resolved options
Inherited from CmpStr.resolveOptions
- Defined in CmpStr.ts:226

rmvFlags

rmvFlags(): this
Removes the normalization flags entirely.

Returns this
Inherited from CmpStr.rmvFlags
- Defined in CmpStr.ts:492

rmvOption

rmvOption(path: string): this
Removes an option at the given path.
Parameters
- path: string
  The path to the option
Returns this
Inherited from CmpStr.rmvOption
- Defined in CmpStr.ts:458

rmvProcessors

rmvProcessors(): this
Removes the processors entirely.

Returns this
Inherited from CmpStr.rmvProcessors
- Defined in CmpStr.ts:507

search

search(
    needle: string,
    haystack: string[],
    flags?: string,
    processors?: CmpStrProcessors,
): string[]
Performs a normalized and filtered substring search.
Parameters
- needle: string
  The search string
- haystack: string[]
  The array to search in
- Optionalflags: string
  Normalization flags
- Optionalprocessors: CmpStrProcessors
  Pre-processors to apply
Returns string[]
- Array of matching entries
Inherited from CmpStr.search
- Defined in CmpStr.ts:681

searchAsync

searchAsync(
    needle: string,
    haystack: string[],
    flags?: string,
    processors?: CmpStrProcessors,
): Promise<string[]>
Asynchronously performs a normalized and filtered substring search.
Parameters
- needle: string
  The search string
- haystack: string[]
  The array to search in
- Optionalflags: string
  Normalization flags
- Optionalprocessors: CmpStrProcessors
  Pre-processors to apply
Returns Promise<string[]>
- Array of matching entries
- Defined in CmpStrAsync.ts:349

setFlags

setFlags(flags: string): this
Sets the normalization flags (e.g., 'itw', 'nfc').
Parameters
- flags: string
  The normalization flags
Returns this
Inherited from CmpStr.setFlags
- Defined in CmpStr.ts:485

setMetric

setMetric(name: string): this
Sets the similatity metric to use (e.g., 'levenshtein', 'dice').
Parameters
- name: string
  The metric name
Returns this
Inherited from CmpStr.setMetric
- Defined in CmpStr.ts:477

setOption

setOption(path: string, value: any): this
Sets a specific option at the given path.
Parameters
- path: string
  The path to the option
- value: any
  The value to set
Returns this
Inherited from CmpStr.setOption
- Defined in CmpStr.ts:447

setOptions

setOptions(opt: CmpStrOptions): this
Sets / replaces the full options object.
Parameters
- opt: CmpStrOptions
  The options
Returns this
Inherited from CmpStr.setOptions
- Defined in CmpStr.ts:413

setProcessors

setProcessors(opt: CmpStrProcessors): this
Sets the pre-processors to use for preparing the input.
Parameters
- opt: CmpStrProcessors
  The processors to set
Returns this
Inherited from CmpStr.setProcessors
- Defined in CmpStr.ts:500

setRaw

setRaw(enable: boolean): this
Enable or disable raw output.
Parameters
- enable: boolean
  Whether to enable or disable raw output
Returns this
Inherited from CmpStr.setRaw
- Defined in CmpStr.ts:469

setSerializedOptions

setSerializedOptions(opt: string): this
Sets the serialized options from a JSON string.
Parameters
- opt: string
  The serialized options
Returns this
Inherited from CmpStr.setSerializedOptions
- Defined in CmpStr.ts:435

`Protected`structured

structured<T = any>(data: T[], key: keyof T): StructuredData<T, R>
Creates a instance for processing structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to compare
Returns StructuredData<T, R>
- The lookup instance
Inherited from CmpStr.structured
- Defined in CmpStr.ts:313

structuredClosest

structuredClosest<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    n?: number,
    opt?: StructuredDataOptions,
): StructuredResultLike<T, R>
Returns the n closest matches from a batch comparison of structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- Optionaln: number = 1
  Number of closest matches
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns StructuredResultLike<T, R>
- Closest matches with objects
Inherited from CmpStr.structuredClosest
- Defined in CmpStr.ts:784

structuredClosestAsync

structuredClosestAsync<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    n?: number,
    opt?: StructuredDataOptions,
): Promise<StructuredResultLike<T, R>>
Asynchronously returns the n closest matches from a batch comparison of structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- Optionaln: number = 1
  Number of closest matches
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns Promise<StructuredResultLike<T, R>>
- Async closest matches
- Defined in CmpStrAsync.ts:459

structuredFurthest

structuredFurthest<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    n?: number,
    opt?: StructuredDataOptions,
): StructuredResultLike<T, R>
Returns the n furthest matches from a batch comparison of structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- Optionaln: number = 1
  Number of furthest matches
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns StructuredResultLike<T, R>
- Furthest matches with objects
Inherited from CmpStr.structuredFurthest
- Defined in CmpStr.ts:804

structuredFurthestAsync

structuredFurthestAsync<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    n?: number,
    opt?: StructuredDataOptions,
): Promise<StructuredResultLike<T, R>>
Asynchronously returns the n furthest matches from a batch comparison of structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- Optionaln: number = 1
  Number of furthest matches
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns Promise<StructuredResultLike<T, R>>
- Async furthest matches
- Defined in CmpStrAsync.ts:482

structuredLookup

structuredLookup<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    opt?: StructuredDataOptions,
): StructuredResultLike<T, R>
Performs a batch comparison against structured data by extracting a specific property and returning results with original objects attached.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns StructuredResultLike<T, R>
- Batch results with original objects
Inherited from CmpStr.structuredLookup
- Defined in CmpStr.ts:743

structuredLookupAsync

structuredLookupAsync<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    opt?: StructuredDataOptions,
): Promise<StructuredResultLike<T, R>>
Asynchronously performs a batch comparison against structured data by extracting a specific property and returning results with original objects attached.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns Promise<StructuredResultLike<T, R>>
- Async batch results with original objects
- Defined in CmpStrAsync.ts:413

structuredMatch

structuredMatch<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    threshold: number,
    opt?: StructuredDataOptions,
): StructuredResultLike<T, R>
Performs a batch comparison and returns only results above the threshold for structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- threshold: number
  The similarity threshold (0..1)
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns StructuredResultLike<T, R>
- Filtered batch results with objects
Inherited from CmpStr.structuredMatch
- Defined in CmpStr.ts:764

structuredMatchAsync

structuredMatchAsync<T = any>(
    query: string,
    data: T[],
    key: keyof T,
    threshold: number,
    opt?: StructuredDataOptions,
): Promise<StructuredResultLike<T, R>>
Asynchronously performs a batch comparison and returns only results above the threshold for structured data.
Type Parameters
- T = any
  The type of objects in the data array
Parameters
- query: string
  The query string to compare against
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- threshold: number
  The similarity threshold (0..1)
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns Promise<StructuredResultLike<T, R>>
- Async filtered batch results
- Defined in CmpStrAsync.ts:436

structuredPairs

structuredPairs<T = any, O = any>(
    data: T[],
    key: keyof T,
    other: O[],
    otherKey: keyof O,
    opt?: StructuredDataOptions,
): StructuredResultLike<T, R>
Performs a pairwise comparison between two arrays of structured objects by extracting specific properties and returning results with original objects attached.
Type Parameters
- T = any
  The type of objects in the arrays
- O = any
  The type of objects in the other array
Parameters
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- other: O[]
  The other array of structured objects
- otherKey: keyof O
  The property key to extract from other array
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns StructuredResultLike<T, R>
- Pairwise results with original objects
Inherited from CmpStr.structuredPairs
- Defined in CmpStr.ts:826

structuredPairsAsync

structuredPairsAsync<T = any, O = any>(
    data: T[],
    key: keyof T,
    other: O[],
    otherKey: keyof O,
    opt?: StructuredDataOptions,
): Promise<StructuredResultLike<T, R>>
Asynchronously performs a pairwise comparison between two arrays of structured objects by extracting specific properties and returning results with original objects attached.
Type Parameters
- T = any
  The type of objects in the arrays
- O = any
  The type of objects in the other array
Parameters
- data: T[]
  The array of structured objects
- key: keyof T
  The property key to extract for comparison
- other: O[]
  The other array of structured objects
- otherKey: keyof O
  The property key to extract from other array
- Optionalopt: StructuredDataOptions
  Optional lookup options
Returns Promise<StructuredResultLike<T, R>>
- Async pairwise results with original objects
- Defined in CmpStrAsync.ts:507

test

test<T extends ResultLike<R> = any>(
    a: string,
    b: string,
    opt?: CmpStrOptions,
): T
Performs a single metric comparison between the source and target.
Type Parameters
- T extends ResultLike<R> = any
  The type of the metric result
Parameters
- a: string
  The source string
- b: string
  The target string
- Optionalopt: CmpStrOptions
  Optional options
Returns T
- The metric result
Inherited from CmpStr.test
- Defined in CmpStr.ts:549

testAsync

testAsync<T extends ResultLike<R> = any>(
    a: string,
    b: string,
    opt?: CmpStrOptions,
): Promise<T>
Asynchronously performs a single metric comparison.
Type Parameters
- T extends ResultLike<R> = any
  The type of the metric result
Parameters
- a: string
  The source string
- b: string
  The target string
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<T>
- The metric result
- Defined in CmpStrAsync.ts:213

`Static`analyze

analyze(input?: string): TextAnalyzer
Returns a TextAnalyzer instance for the given input string.
Parameters
- Optionalinput: string
  The input string
Returns TextAnalyzer
- The text analyzer
Inherited from CmpStr.analyze
- Defined in CmpStr.ts:133

`Static`create

create<R = MetricRaw>(opt?: string | CmpStrOptions): CmpStrAsync<R>
Creates a new CmpStrAsync instance with the given options.
Type Parameters
- R = MetricRaw
Parameters
- Optionalopt: string | CmpStrOptions
  Optional serialized or options object
Returns CmpStrAsync<R>
- A new CmpStrAsync instance
Overrides CmpStr.create
- Defined in CmpStrAsync.ts:64

`Static`diff

diff(a: string, b: string, opt?: DiffOptions): DiffChecker
Returns a DiffChecker instance for computing the unified diff between two texts.
Parameters
- a: string
  The first (original) text
- b: string
  The second (modified) text
- Optionalopt: DiffOptions
  Optional diff configuration
Returns DiffChecker
- The diff checker instance
Inherited from CmpStr.diff
- Defined in CmpStr.ts:143

Class CmpStrAsync<R>

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

Protectedconstructor

Type Parameters

Parameters

Returns CmpStrAsync<R>

Properties

Protectedoptions

Static ReadonlyclearCache

Type Declaration

filter: () => void

metric: () => void

normalizer: () => void

phonetic: () => void

Static Readonlyfilter

Type Declaration

add: (hook: FilterHooks, id: string, fn: FilterFn, opt?: FilterOptions) => boolean

clear: (hook?: FilterHooks) => void

has: (hook: FilterHooks, id: string) => boolean

list: (hook: FilterHooks, active?: boolean) => string[]

pause: (hook: FilterHooks, id: string) => boolean

remove: (hook: FilterHooks, id: string) => boolean

resume: (hook: FilterHooks, id: string) => boolean

See

Static Readonlymetric

See

Static Readonlyphonetic

See

Static Readonlyprofiler

See

Methods

Protectedassert

Parameters

Returns void

Throws

ProtectedassertMany

Parameters

Returns void

batchSorted

Type Parameters

Parameters

Returns T

batchSortedAsync

Type Parameters

Parameters

Returns Promise<T>

batchTest

Type Parameters

Parameters

Returns T

batchTestAsync

Type Parameters

Parameters

Returns Promise<T>

clone

Returns CmpStr<R>

closest

Type Parameters

Parameters

Returns T

closestAsync

Type Parameters

Parameters

Returns Promise<T>

compare

Parameters

Returns number

compareAsync

Parameters

Returns Promise<number>

Protectedcompute

Type Parameters

Parameters

Returns T

`Protected`constructor

`Protected`options

`Static` `Readonly`clearCache

`Static` `Readonly`filter

`Static` `Readonly`metric

`Static` `Readonly`phonetic

`Static` `Readonly`profiler

`Protected`assert

`Protected`assertMany

`Protected`compute

`Protected`computeAsync

`Protected`filter

`Protected`filterAsync

`Protected`index

`Protected`indexAsync

`Protected`normalize

`Protected`normalizeAsync

`Protected`output