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:76

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 specified metric or phonetic algorithm is not found
Throws
- If an unknown condition is specified
Inherited from CmpStr.assert
- Defined in CmpStr.ts:203

`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:216

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:649

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:271

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:633

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:255

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:409

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:708

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:332

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:619

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:241

`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
Throws
- If the options are invalid
Throws
- If the computation fails due to internal errors
Inherited from CmpStr.compute
- Defined in CmpStr.ts:337

`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
Throws
- If the options are invalid
Throws
- If the computation fails due to internal errors
- Defined in CmpStrAsync.ts:168

`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:253

`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:107

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:724

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:348

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:585

getOptions

getOptions(): CmpStrOptions
Returns the current options object.

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

getSerializedOptions

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

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

`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:299

`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:141

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:688

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:311

matrix

matrix(input: string[], opt?: CmpStrOptions): number[][]
Computes a similarity matrix for the given input array.

Only works for symmetric metrics.
Parameters
- input: string[]
  The input array
- Optionalopt: CmpStrOptions
  Optional options
Returns number[][]
- The similarity matrix
Inherited from CmpStr.matrix
- Defined in CmpStr.ts:766

matrixAsync

matrixAsync(input: string[], opt?: CmpStrOptions): Promise<number[][]>
Asynchronously computes a similarity matrix for the given input array.

Only works for symmetric metrics.
Parameters
- input: string[]
  The input array
- Optionalopt: CmpStrOptions
  Optional options
Returns Promise<number[][]>
- The similarity matrix
- Defined in CmpStrAsync.ts:390

mergeOptions

mergeOptions(opt: CmpStrOptions): this
Deep merges and sets new options.
Parameters
- opt: CmpStrOptions
  The options to merge
Returns this
Throws
- If the merged options are invalid
Inherited from CmpStr.mergeOptions
- Defined in CmpStr.ts:447

`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:242

`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:96

`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
Throws
- If the output format cannot be resolved
Inherited from CmpStr.output
- Defined in CmpStr.ts:386

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:672

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:295

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:794

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:420

`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:285

`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:264

`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:118

reset

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

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

`Protected`resolveOptions

resolveOptions(opt?: CmpStrOptions): CmpStrOptions
Resolves the options for the CmpStr instance, merging the provided options with the existing options. Validates them and throws if the options are invalid.
Parameters
- Optionalopt: CmpStrOptions
  Optional options to merge
Returns CmpStrOptions
- The resolved options
Throws
- If the merged options are invalid
Inherited from CmpStr.resolveOptions
- Defined in CmpStr.ts:228

rmvFlags

rmvFlags(): this
Removes the normalization flags entirely.

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

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:498

rmvProcessors

rmvProcessors(): this
Removes the processors entirely.

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

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:739

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:363

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:529

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:519

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
Throws
- If the updated options are invalid
Inherited from CmpStr.setOption
- Defined in CmpStr.ts:486

setOptions

setOptions(opt: CmpStrOptions): this
Sets / replaces the full options object.
Parameters
- opt: CmpStrOptions
  The options
Returns this
Throws
- If the provided options are invalid
Inherited from CmpStr.setOptions
- Defined in CmpStr.ts:433

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:548

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:509

setSerializedOptions

setSerializedOptions(opt: string): this
Sets the serialized options from a JSON string.
Parameters
- opt: string
  The serialized options
Returns this
Throws
- If the provided string is not valid JSON or the options are invalid
Inherited from CmpStr.setSerializedOptions
- Defined in CmpStr.ts:461

`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:318

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:860

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:487

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:880

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:508

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:819

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:445

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:840

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:466

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:902

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:531

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:607

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:227

`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:138

`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:67

`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:150

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

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

`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