Class CmpStr<R>

The main CmpStr class that provides a unified interface for string comparison, phonetic indexing, filtering, and text analysis.

Type Parameters

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

Hierarchy (View Summary)

CmpStr
- CmpStrAsync

Constructors

`Protected`constructor

new CmpStr<R = MetricRaw>(opt?: string | CmpStrOptions): CmpStr<R>
Creates a new CmpStr instance with the given options. The constructor is protected to enforce the use of the static create method.
Type Parameters
- R = MetricRaw
  The type of the metric result, defaults to MetricRaw
Parameters
- Optionalopt: string | CmpStrOptions
  Optional serialized or options object
Returns CmpStr<R>
- Defined in CmpStr.ts:173

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
- 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
- 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
- Defined in CmpStr.ts:591

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
- Defined in CmpStr.ts:575

clone

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

Returns CmpStr<R>
- The cloned instance
- 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
- Defined in CmpStr.ts:650

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)
- Defined in CmpStr.ts:561

`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
- Defined in CmpStr.ts:330

`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)
- Defined in CmpStr.ts:248

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
- Defined in CmpStr.ts:666

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
- Defined in CmpStr.ts:529

getOptions

getOptions(): CmpStrOptions
Returns the current options object.

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

getSerializedOptions

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

Returns string
- The serialized options
- 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
- Defined in CmpStr.ts:294

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
- Defined in CmpStr.ts:630

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
- Defined in CmpStr.ts:701

mergeOptions

mergeOptions(opt: CmpStrOptions): this
Deep merges and sets new options.
Parameters
- opt: CmpStrOptions
  The options to merge
Returns this
- 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
- Defined in CmpStr.ts:237

`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
- 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
- Defined in CmpStr.ts:614

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
- Defined in CmpStr.ts:718

`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
- 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
- Defined in CmpStr.ts:259

reset

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

Returns this
- 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
- Defined in CmpStr.ts:226

rmvFlags

rmvFlags(): this
Removes the normalization flags entirely.

Returns this
- 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
- Defined in CmpStr.ts:458

rmvProcessors

rmvProcessors(): this
Removes the processors entirely.

Returns this
- 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
- Defined in CmpStr.ts:681

setFlags

setFlags(flags: string): this
Sets the normalization flags (e.g., 'itw', 'nfc').
Parameters
- flags: string
  The normalization flags
Returns this
- 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
- 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
- Defined in CmpStr.ts:447

setOptions

setOptions(opt: CmpStrOptions): this
Sets / replaces the full options object.
Parameters
- opt: CmpStrOptions
  The options
Returns this
- 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
- 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
- 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
- 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
- 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
- Defined in CmpStr.ts:784

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
- Defined in CmpStr.ts:804

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
- Defined in CmpStr.ts:743

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
- Defined in CmpStr.ts:764

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
- Defined in CmpStr.ts:826

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
- Defined in CmpStr.ts:549

`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
- Defined in CmpStr.ts:133

`Static`create

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

`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
- Defined in CmpStr.ts:143

Class CmpStr<R>

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

Protectedconstructor

Type Parameters

Parameters

Returns CmpStr<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

batchTest

Type Parameters

Parameters

Returns T

clone

Returns CmpStr<R>

closest

Type Parameters

Parameters

Returns T

compare

Parameters

Returns number

Protectedcompute

Type Parameters

Parameters

Returns T

Protectedfilter

Parameters

Returns MetricInput

furthest

Type Parameters

Parameters

Returns T

getOption

Parameters

Returns any

getOptions

Returns CmpStrOptions

getSerializedOptions

Returns string

Protectedindex

`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`filter

`Protected`index

`Protected`normalize

`Protected`output

`Protected`postProcess

`Protected`prepare

`Protected`resolveOptions

`Protected`structured