FlexSearch is a next-generation full-text search library that provides high-performance search capabilities for both browser and Node.js environments. It offers advanced features including phonetic transformations, partial matching, multi-field document search, fuzzy search, context-aware search, tag-based search, result highlighting, and suggestions with support for multiple database backends for persistent indexes.
npm install flexsearch// Default import (contains all classes)
import FlexSearch from "flexsearch";
const { Index, Document, Worker, Encoder, Charset, Resolver, IndexedDB } = FlexSearch;
// Named imports
import { Index, Document, Worker, Encoder, Charset, Resolver, IndexedDB } from "flexsearch";CommonJS:
// Default import
const FlexSearch = require("flexsearch");
const { Index, Document, Worker, Encoder, Charset, Resolver, IndexedDB } = FlexSearch;
// Named imports
const { Index, Document, Worker, Encoder, Charset, Resolver, IndexedDB } = require("flexsearch");Database adapters and language packs:
// Database adapters
import IndexedDB from "flexsearch/db/indexeddb";
import Redis from "flexsearch/db/redis";
import PostgreSQL from "flexsearch/db/postgres";
// Language packs
import EnglishPack from "flexsearch/lang/en";
import GermanPack from "flexsearch/lang/de";import { Index } from "flexsearch";
// Create a basic search index
const index = new Index();
// Add documents
index.add(1, "The quick brown fox jumps over the lazy dog");
index.add(2, "A journey of a thousand miles begins with a single step");
// Search
const results = index.search("quick");
console.log(results); // [1]import { Document } from "flexsearch";
// Create document index with field configuration
const index = new Document({
document: {
id: "id",
index: ["title", "content"],
store: ["title", "content", "author"]
}
});
// Add documents
index.add({
id: 1,
title: "Getting Started with FlexSearch",
content: "FlexSearch is a powerful full-text search library...",
author: "John Doe"
});
// Search across fields
const results = index.search("FlexSearch");
console.log(results);FlexSearch is built around several key components:
Core full-text search functionality for simple string-based indexing and retrieval. Perfect for basic search implementations with maximum performance.
class Index<W, S, R> {
constructor(options?: Preset | IndexOptions<S, R>);
add(id: Id, content: string): this | Promise<this>;
search(query: string, options?: SearchOptions<R>): SearchResults<W, S, R>;
remove(id: Id): this | Promise<this>;
}
type Id = number | string;
type Preset = "memory" | "performance" | "match" | "score" | "default";Advanced document indexing with multi-field support, structured data handling, and field-specific search configurations. Ideal for complex search scenarios with heterogeneous data.
class Document<D, W, S, R> {
constructor(options: DocumentOptions<D, W, S, R>);
add(document: D): this | Promise<this>;
add(id: Id, document: D): this | Promise<this>;
search(query: string, options?: DocumentSearchOptions): DocumentSearchResults<D, W, S, R>;
}
interface DocumentOptions<D, W, S, R> extends IndexOptions<S, R> {
document: DocumentDescriptor<D>;
worker?: WorkerType;
}Comprehensive text processing system with language-specific encoders, character set support, and custom tokenization strategies for optimal search performance across different languages and use cases.
class Encoder {
constructor(options?: EncoderOptions);
encode(content: string): string[];
addMapper(char_match: string, char_replace: string): this;
addMatcher(match: string, replace: string): this;
}
const Charset: {
Default: EncoderOptions;
LatinAdvanced: EncoderOptions;
CJK: EncoderOptions;
// ... additional charset configurations
};Database abstraction layer supporting multiple storage backends for scalable search applications with persistent indexes and cross-session data retention.
class StorageInterface {
constructor(name: string, config: PersistentOptions);
mount(index: Index | Document): Promise<void>;
open(): Promise<void>;
close(): Promise<void>;
}
// Available storage adapters
import IndexedDB from "flexsearch/db/indexeddb";
import Redis from "flexsearch/db/redis";
import PostgreSQL from "flexsearch/db/postgres";Boolean query operations and advanced result manipulation for complex search scenarios requiring logical operations, result boosting, and custom scoring.
class Resolver {
constructor(options?: ResolverOptions);
and(...args: any[]): this;
or(...args: any[]): this;
not(...args: any[]): this;
resolve(options?: any): any;
}Non-blocking search operations using Web Workers for maintaining UI responsiveness during intensive search operations in browser environments.
class Worker extends Promise {
constructor(options?: Preset | WorkerIndexOptions);
export(): Promise<void>;
import(): Promise<void>;
}type Id = number | string;
type Limit = number;
type Preset = "memory" | "performance" | "match" | "score" | "default";
type Tokenizer = "strict" | "exact" | "default" | "tolerant" | "forward" | "reverse" | "bidirectional" | "full";
interface SearchOptions<R extends boolean = true> {
query?: string;
limit?: number;
offset?: number;
suggest?: boolean;
resolution?: number;
context?: boolean;
cache?: R extends true ? boolean : false;
resolve?: R;
}
interface IndexOptions<S, R> {
preset?: Preset;
tokenize?: Tokenizer;
cache?: boolean | number;
resolution?: number;
context?: ContextOptions | boolean;
encoder?: Encoders | EncoderOptions | Encoder;
db?: S;
commit?: boolean;
}