@tinacms/search 0.0.0-ef282d9-20241024212433 → 0.0.0-f1cec43-20251216232909

package/README.md

@@ -0,0 +1,55 @@
+# @tinacms/search
+
+Full-text search for TinaCMS powered by [search-index](https://github.com/fergiemcdowall/search-index).
+
+## Installation
+
+```bash
+pnpm add @tinacms/search
+```
+
+## Usage
+
+```typescript
+import { LocalSearchIndexClient } from "@tinacms/search";
+
+const client = new LocalSearchIndexClient({
+  stopwordLanguages: ["eng"],
+});
+
+await client.onStartIndexing();
+
+await client.put([
+  {
+    _id: "1",
+    title: "Getting Started",
+    body: "TinaCMS is a Git-backed headless CMS",
+  },
+  {
+    _id: "2",
+    title: "React Tutorial",
+    body: "Learn how to build React applications",
+  },
+]);
+
+// Basic search
+const results = await client.query("TinaCMS", { limit: 10 });
+
+// Fuzzy search (handles typos)
+const fuzzyResults = await client.query("TinCMS tutrial", {
+  fuzzy: true,
+  limit: 10,
+});
+```
+
+## API
+
+- `client.onStartIndexing()` - Initialize the index
+- `client.put(documents)` - Index documents
+- `client.query(query, options)` - Search the index
+- `client.del(ids)` - Delete documents
+- `client.export(filename)` - Export index to SQLite
+
+## License
+
+Apache 2.0

package/dist/client/index.d.ts

@@ -1,5 +1,24 @@
-import type { SearchClient } from '../types';
+import type { SearchClient, SearchOptions, SearchQueryResponse, IndexableDocument, SearchIndexResult } from '../types';
 import { MemoryLevel } from 'memory-level';
+import { FuzzySearchWrapper } from '../fuzzy-search-wrapper';
+interface SearchIndex {
+    PUT: (docs: IndexableDocument[]) => Promise<void>;
+    DELETE: (ids: string[]) => Promise<void>;
+    QUERY: (query: {
+        AND: string[];
+    } | {
+        OR: string[];
+    }, options?: {
+        PAGE?: {
+            NUMBER: number;
+            SIZE: number;
+        };
+    }) => Promise<SearchIndexResult>;
+    DICTIONARY: (token?: {
+        FIELD: string;
+    }) => Promise<unknown[]>;
+    fuzzySearchWrapper?: FuzzySearchWrapper;
+}
 type TinaSearchIndexerClientOptions = {
     stopwordLanguages?: string[];
     tokenSplitRegex?: string;
@@ -10,23 +29,16 @@ type TinaCloudSearchIndexerClientOptions = {
     indexerToken: string;
 } & TinaSearchIndexerClientOptions;
 export declare class LocalSearchIndexClient implements SearchClient {
-    searchIndex: any;
+    searchIndex?: SearchIndex;
     protected readonly memoryLevel: MemoryLevel;
     private readonly stopwords;
     private readonly tokenSplitRegex;
+    fuzzySearchWrapper?: FuzzySearchWrapper;
     constructor(options: TinaSearchIndexerClientOptions);
     onStartIndexing(): Promise<void>;
-    put(docs: any[]): Promise<any>;
-    del(ids: string[]): Promise<any>;
-    query(query: string, options: {
-        cursor?: string;
-        limit?: number;
-    } | undefined): Promise<{
-        results: any[];
-        total: number;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    }>;
+    put(docs: IndexableDocument[]): Promise<void>;
+    del(ids: string[]): Promise<void>;
+    query(query: string, options?: SearchOptions): Promise<SearchQueryResponse>;
     export(filename: string): Promise<void>;
 }
 export declare class TinaCMSSearchIndexClient extends LocalSearchIndexClient {
@@ -34,6 +46,9 @@ export declare class TinaCMSSearchIndexClient extends LocalSearchIndexClient {
     private readonly branch;
     private readonly indexerToken;
     constructor(options: TinaCloudSearchIndexerClientOptions);
+    private getUploadUrl;
+    private serializeIndex;
+    private uploadIndex;
     onFinishIndexing(): Promise<void>;
 }
 export {};

package/dist/fuzzy/cache.d.ts

@@ -0,0 +1,11 @@
+import type { FuzzyMatch, FuzzySearchOptions } from './types';
+export declare class FuzzyCache {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    private getCacheKey;
+    get(query: string, options: Partial<FuzzySearchOptions>): FuzzyMatch[] | undefined;
+    set(query: string, options: Partial<FuzzySearchOptions>, results: FuzzyMatch[]): void;
+    clear(): void;
+    get size(): number;
+}

package/dist/fuzzy/distance.d.ts

@@ -0,0 +1,15 @@
+import type { FuzzySearchOptions, FuzzyMatch } from './types';
+export declare function levenshteinDistance(str1: string, str2: string): number;
+export declare function similarityScore(str1: string, str2: string, useTranspositions?: boolean): number;
+export declare function damerauLevenshteinDistance(str1: string, str2: string): number;
+/**
+ * Generate n-grams (character sequences) from a string
+ * Example: getNgrams("react", 2) => Set{"re", "ea", "ac", "ct"}
+ */
+export declare function getNgrams(str: string, n?: number): Set<string>;
+/**
+ * Calculate the overlap ratio between two sets of n-grams
+ * Returns a value between 0 and 1
+ */
+export declare function ngramOverlap(ngrams1: Set<string>, ngrams2: Set<string>): number;
+export declare function findSimilarTerms(query: string, dictionary: string[], options?: FuzzySearchOptions): FuzzyMatch[];

package/dist/fuzzy/index.d.ts

@@ -0,0 +1,4 @@
+export type { FuzzySearchOptions, FuzzyMatch } from './types';
+export { DEFAULT_FUZZY_OPTIONS } from './types';
+export { FuzzyCache } from './cache';
+export { levenshteinDistance, similarityScore, damerauLevenshteinDistance, findSimilarTerms, getNgrams, ngramOverlap, } from './distance';

package/dist/fuzzy/types.d.ts

@@ -0,0 +1,19 @@
+export interface FuzzySearchOptions {
+    maxDistance?: number;
+    minSimilarity?: number;
+    maxResults?: number;
+    useTranspositions?: boolean;
+    caseSensitive?: boolean;
+    /** Use n-gram filtering for candidate selection (supports transpositions) */
+    useNgramFilter?: boolean;
+    /** Size of n-grams for filtering (default: 2) */
+    ngramSize?: number;
+    /** Minimum n-gram overlap ratio to consider a candidate (0-1, default: 0.2) */
+    minNgramOverlap?: number;
+}
+export interface FuzzyMatch {
+    term: string;
+    distance: number;
+    similarity: number;
+}
+export declare const DEFAULT_FUZZY_OPTIONS: Required<FuzzySearchOptions>;

package/dist/fuzzy-search-wrapper.d.ts

@@ -0,0 +1,46 @@
+import type { FuzzySearchOptions, FuzzyMatch } from './fuzzy';
+import type { SearchQueryResponse, SearchResult } from './types';
+interface SearchIndex {
+    QUERY: (query: {
+        AND: string[];
+    } | {
+        OR: string[];
+    } | {
+        AND: (string | {
+            OR: string[];
+        })[];
+    }, options?: {
+        PAGE?: {
+            NUMBER: number;
+            SIZE: number;
+        };
+    }) => Promise<{
+        RESULT: SearchResult[];
+        RESULT_LENGTH: number;
+    }>;
+    DICTIONARY: (token?: {
+        FIELD: string;
+    }) => Promise<unknown[]>;
+}
+interface QueryOptions {
+    limit?: number;
+    cursor?: string;
+    fuzzy?: boolean;
+    fuzzyOptions?: FuzzySearchOptions;
+}
+export declare class FuzzySearchWrapper {
+    private cache;
+    private searchIndex;
+    constructor(searchIndex: SearchIndex, cacheSize?: number);
+    getDictionary(field?: string): Promise<string[]>;
+    findSimilar(query: string, field?: string, options?: FuzzySearchOptions): Promise<FuzzyMatch[]>;
+    expandQuery(query: string, options?: FuzzySearchOptions): Promise<{
+        original: string[];
+        expanded: string[];
+        matches: Record<string, FuzzyMatch[]>;
+    }>;
+    query(query: string, options?: QueryOptions): Promise<SearchQueryResponse>;
+    clearCache(): void;
+    getCacheSize(): number;
+}
+export {};

package/dist/index-client.d.ts

@@ -1,16 +1,33 @@
-export type { SearchClient } from './types';
+export type { SearchClient, SearchResult, SearchQueryResponse, IndexableDocument, } from './types';
 export { processDocumentForIndexing } from './indexer/utils';
-export declare const queryToSearchIndexQuery: (query: string, stopwordLanguages?: string[]) => any;
-export declare const optionsToSearchIndexOptions: (options?: {
+import type { FuzzyMatch } from './fuzzy';
+interface SearchQuery {
+    AND: string[];
+}
+interface PaginationOptions {
     limit?: number;
     cursor?: string;
-}) => {};
-export declare const parseSearchIndexResponse: (data: any, options?: {
-    limit?: number;
-    cursor?: string;
-}) => {
-    results: any;
-    total: any;
-    prevCursor: any;
-    nextCursor: string;
-};
+}
+interface PageOptions {
+    PAGE?: {
+        SIZE: number;
+        NUMBER: number;
+    };
+}
+interface SearchIndexResponse {
+    RESULT: unknown[];
+    RESULT_LENGTH: number;
+    FUZZY_MATCHES?: Record<string, FuzzyMatch[]>;
+    NEXT_CURSOR?: string | null;
+    PREV_CURSOR?: string | null;
+}
+interface ParsedSearchResponse {
+    results: unknown[];
+    total: number;
+    prevCursor: string | null;
+    nextCursor: string | null;
+    fuzzyMatches?: Record<string, FuzzyMatch[]>;
+}
+export declare const queryToSearchIndexQuery: (query: string, stopwordLanguages?: string[]) => SearchQuery;
+export declare const optionsToSearchIndexOptions: (options?: PaginationOptions) => PageOptions;
+export declare const parseSearchIndexResponse: (data: SearchIndexResponse, options?: PaginationOptions) => ParsedSearchResponse;