lucene-kit/dist/index.d.ts

Lightweight and extensive, Lucene-like solution provides powerful full-text search, serialization, and parser for your application.

interface Node {
    type: NodeType;
}
declare enum NodeType {
    LogicalGroup = "logical-group",
    FieldGroup = "field-group",
    Conjunction = "conjunction",
    Negation = "negation",
    Term = "term",
    Exists = "exists",
    Range = "range",
    Regexp = "regexp",
    Wildcard = "wildcard",
    Empty = "empty",
    Function = "function",
    TermList = "term-list"
}
interface TermLikeNode extends Node {
    type: TermLikeType;
    field: Field;
    analyzed?: boolean;
}
type FieldValue<T> = FieldValueValue<T> | FieldValueVariable;
interface FieldValueValue<T> {
    type: 'value';
    value: T;
}
interface FieldValueVariable {
    type: 'variable';
    scoped: boolean;
    value: string;
}
type TermLikeType = NodeType.Term | NodeType.Regexp | NodeType.Range | NodeType.Wildcard | NodeType.Function | NodeType.TermList;
type Field = string | null;
interface TermList extends TermLikeNode {
    type: NodeType.TermList;
    value: FieldValue<any>[];
}
interface Term extends AnyDataType, TermLikeNode {
    type: NodeType.Term;
}
interface VariableNode extends TermLikeNode {
    value: FieldValueVariable;
}
interface FunctionNode extends TermLikeNode {
    type: NodeType.Function;
    name: string;
    description?: string;
    params: (Term | TermList)[];
}
interface AnyDataType {
    value: FieldValue<any>;
}

/**
 * Class representing a Lucene query parser.
 */
declare class QueryParser {
    private readonly luceneQuery;
    private cachedAst?;
    /**
     * Creates an instance of QueryParser.
     * @param luceneQuery The Lucene query string to parse.
     */
    constructor(luceneQuery: string);
    /**
     * Parses the Lucene query string into an abstract syntax tree (AST).
     * @returns The QueryParser instance
     */
    parse(): this;
    private cacheAst;
    /**
     * Converts the Lucene query string to an abstract syntax tree (AST).
     * @returns The abstract syntax tree (AST) representing the parsed query.
     */
    toAST(): Node;
}

type FlatType = string | number | undefined | boolean | null | Date;

/**
 * return type of a variable resolver, which can be a FlatType or a QueryParser instance.
 */
type VariableResolverReturnType = FlatType | QueryParser;
/**
 * a mapping from variable names to resolver functions or resolved values.
 */
type VariableResolver = {
    [name: string]: ((node: VariableNode | FieldValueVariable) => VariableResolverReturnType) | VariableResolverReturnType;
};
/**
 * the return type of a function resolver, which can be a FlatType, a QueryParser instance,
 * or an object containing resolved value and filtered data.
 */
type FunctionResolverReturnType<T> = FlatType | QueryParser | {
    resolved?: VariableResolverReturnType;
    data?: T;
};
/**
 * a callback function for resolving functions, taking a function node and filtered data,
 * and returning the resolved value or an object containing resolved value and filtered data.
 */
type FunctionResolverCallBack<T> = (node: FunctionNode, data: T) => FunctionResolverReturnType<T>;
/**
 * a function resolver, a mapping from function names to resolver callback functions.
 */
type FunctionResolver = {
    [name: string]: FunctionResolverCallBack<any>;
};
/**
 * A class for resolving references, including variables and functions.
 */
declare class ReferenceResolver {
    private variablesResolver;
    private functionResolver;
    /**
     * Creates an instance of ReferenceResolver.
     * @param variablesResolver The variable resolver mapping.
     * @param functionResolver The function resolver mapping.
     */
    constructor(variablesResolver?: VariableResolver, functionResolver?: FunctionResolver);
    /**
     * Adds a variable resolver to the resolver mapping.
     * @param name The name of the variable.
     * @param resolver The resolver function or resolved value.
     * @returns The ReferenceResolver instance for chaining.
     */
    addVariableResolver(name: string, resolver: VariableResolver['']): this;
    /**
     * Adds a function resolver to the resolver mapping.
     * @param name The name of the function.
     * @param resolver The callback function for resolving the function.
     * @returns The ReferenceResolver instance for chaining.
     */
    addFunctionResolver(name: string, resolver: FunctionResolverCallBack<any>): this;
    /**
     * Resolves a variable node to its value using the variable resolver mapping.
     * @param node The variable node to resolve.
     * @returns The resolved value.
     */
    resolveVariable(node: VariableNode | FieldValueVariable): VariableResolverReturnType;
    /**
     * Resolves a function node to its value using the function resolver mapping.
     * @param node The function node to resolve.
     * @param data Additional data to pass to the resolver.
     * @returns The resolved value or an object containing resolved value and additional data.
     */
    resolveFunction<T = any>(node: FunctionNode, data: T): FunctionResolverReturnType<T>;
}

interface IteratorConfig {
    /**
     * Defaults to Infinity
     */
    maxDepth: number;
    /**
     * Feature flag to control whether private fields should no be iterated for wildcard queries, if not explicitly specified
     */
    featureEnablePrivateField: boolean;
}

/**
 * Filters an array of data based on the lucene query.
 * @param queryInstance The QueryParser instance containing the lucene query.
 * @param data The array of data to filter.
 * @param resolver Optional reference resolver to resolve variables and functions in the query.
 * @param iteratorConfig Optional iterator config to control the behavior of the object iterator
 * @returns The filtered array of data.
 */
declare function filter<T = unknown>(queryInstance: QueryParser, data: T[], resolver?: ReferenceResolver, iteratorConfig?: IteratorConfig): T[];

export { QueryParser, ReferenceResolver, filter };