or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

document-search.mdindex-search.mdindex.mdpersistent-storage.mdquery-resolution.mdtext-processing.mdworker-search.md
tile.json

tessl/npm-flexsearch

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

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/flexsearch@0.8.x

To install, run

npx @tessl/cli install tessl/npm-flexsearch@0.8.0

index.mddocs/

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