CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-flexsearch

Next-generation full-text search library for Browser and Node.js with advanced features and multi-database support

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

FlexSearch

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.

Package Information

  • Package Name: flexsearch
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install flexsearch

Core Imports

// 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";

Basic Usage

Simple Index Search

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]

Document Search with Multiple Fields

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);

Architecture

FlexSearch is built around several key components:

  • Index Class: Basic full-text search for simple string-based searches with high performance
  • Document Class: Advanced multi-field document search with structured data support and field-specific configurations
  • Worker Class: Web Worker implementation for non-blocking search operations in browser environments
  • Encoder System: Comprehensive text processing pipeline with language-specific optimizations and custom encoding support
  • Storage Interface: Persistent storage abstraction supporting multiple database backends (IndexedDB, Redis, PostgreSQL, etc.)
  • Resolver System: Advanced query resolution for complex boolean operations and result manipulation

Capabilities

Basic Index Search

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";

Index Search

Document Search

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;
}

Document Search

Text Processing & Encoding

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
};

Text Processing

Persistent Storage

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";

Persistent Storage

Advanced Query Resolution

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;
}

Query Resolution

Worker-Based Search

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>;
}

Worker Search

Types

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;
}
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/flexsearch@0.8.x
Publish Source
CLI
Badge
tessl/npm-flexsearch badge