cry-search 1.0.0

package/dist/common/SearchUniverse.d.ts

@@ -0,0 +1,210 @@
+import type { Id, NumericSearchMetadata, SearchableData, SearchableObject, UniversalSearchOpts, CollectionConfig, UpdateResult, BatchUpdateResult } from '../types';
+export type { UniversalSearchOpts, CollectionConfig, UpdateResult, BatchUpdateResult } from '../types';
+/**
+ * SearchUniverse manages multiple collections with their metadata and relationships.
+ * Provides unified update methods that automatically handle linked data indexes.
+ *
+ * @example
+ * ```typescript
+ * const universe = new SearchUniverse();
+ *
+ * // Register collections
+ * universe.registerCollection<Stranka>('stranke', {
+ *   spec: { searchInFields: ['name', 'address'] }
+ * });
+ *
+ * universe.registerCollection<Pacient>('pacienti', {
+ *   spec: { dontSearchInFields: ['stranka_id'] },
+ *   linkedTo: {
+ *     collectionName: 'stranke',
+ *     foreignKeyGetter: (p) => p.stranka_id
+ *   }
+ * });
+ *
+ * // Load initial data
+ * universe.loadCollection('stranke', strankeArray);
+ * universe.loadCollection('pacienti', pacientiArray);
+ *
+ * // Update items - automatically handles metadata and indexes
+ * universe.updateSearchMetadata('pacienti', 'p1', updatedPacient);
+ * ```
+ */
+export declare class SearchUniverse {
+    private collections;
+    /**
+     * Registers a new collection with optional configuration.
+     *
+     * @param name - Unique name for the collection
+     * @param config - Configuration including spec and links
+     */
+    registerCollection<T extends SearchableObject, C = unknown>(name: string, config?: CollectionConfig<T, C>): void;
+    /**
+     * Checks if a collection exists.
+     *
+     * @param name - Collection name to check
+     * @returns True if the collection is registered
+     */
+    hasCollection(name: string): boolean;
+    /**
+     * Gets all registered collection names.
+     *
+     * @returns Array of collection names
+     */
+    getCollectionNames(): string[];
+    /**
+     * Loads data into a collection, replacing any existing data.
+     * Builds metadata and updates linked indexes.
+     *
+     * @param name - Collection name
+     * @param items - Array of items to load
+     */
+    loadCollection<T extends SearchableObject>(name: string, items: T[]): void;
+    /**
+     * Gets an item from a collection by ID.
+     *
+     * @typeParam T - Type of the item
+     * @param collectionName - Name of the collection
+     * @param id - ID of the item to retrieve
+     * @returns The item, or undefined if not found
+     */
+    getItem<T extends SearchableObject>(collectionName: string, id: Id): T | undefined;
+    /**
+     * Gets all items from a collection.
+     *
+     * @typeParam T - Type of items in the collection
+     * @param collectionName - Name of the collection
+     * @returns Array of all items
+     */
+    getItems<T extends SearchableObject>(collectionName: string): T[];
+    /**
+     * Gets the number of items in a collection.
+     *
+     * @param collectionName - Name of the collection
+     * @returns Number of items in the collection
+     */
+    getCollectionSize(collectionName: string): number;
+    /**
+     * Gets the search metadata for a collection.
+     *
+     * @param collectionName - Name of the collection
+     * @returns The NumericSearchMetadata map (id -> Uint32Array of token IDs)
+     */
+    getMetadata(collectionName: string): NumericSearchMetadata;
+    /**
+     * Gets the data map for a collection.
+     *
+     * @typeParam T - Type of items in the collection
+     * @param collectionName - Name of the collection
+     * @returns The SearchableData map (id -> item)
+     */
+    getData<T extends SearchableObject>(collectionName: string): SearchableData<T>;
+    /**
+     * Gets linked item IDs for a primary item.
+     *
+     * @param linkedCollectionName - Name of the linked collection
+     * @param primaryId - ID of the primary item
+     * @returns Array of linked item IDs (empty if none)
+     * @throws Error if the collection is not a linked collection
+     */
+    getLinkedIds(linkedCollectionName: string, primaryId: Id): Id[];
+    /**
+     * Gets linked items for a primary item.
+     *
+     * @typeParam T - Type of linked items
+     * @param linkedCollectionName - Name of the linked collection
+     * @param primaryId - ID of the primary item
+     * @returns Array of linked items (empty if none)
+     */
+    getLinkedItems<T extends SearchableObject>(linkedCollectionName: string, primaryId: Id): T[];
+    /**
+     * Updates search metadata for a single item.
+     * Automatically handles:
+     * - Adding new items
+     * - Updating existing items
+     * - Removing items marked as _deleted or _blocked
+     * - Updating linked indexes when foreign key changes
+     *
+     * @param collectionName - Name of the collection
+     * @param id - ID of the item to update
+     * @param item - The item (may be deleted/blocked)
+     * @returns UpdateResult indicating if item was added/updated/removed
+     */
+    updateSearchMetadata<T extends SearchableObject>(collectionName: string, id: Id, item: T): UpdateResult;
+    /**
+     * Updates search metadata for multiple items in a batch.
+     *
+     * @param collectionName - Name of the collection
+     * @param items - Array of items to update (each must have _id)
+     * @returns BatchUpdateResult with counts
+     */
+    updateSearchMetadataBatch<T extends SearchableObject>(collectionName: string, items: T[]): BatchUpdateResult;
+    /**
+     * Removes an item from a collection by ID.
+     *
+     * @param collectionName - Name of the collection
+     * @param id - ID of the item to remove
+     * @returns true if item was found and removed
+     */
+    removeFromSearchMetadata(collectionName: string, id: Id): boolean;
+    /**
+     * Removes multiple items from a collection by IDs.
+     *
+     * @param collectionName - Name of the collection
+     * @param ids - Array of IDs to remove
+     * @returns Number of items actually removed
+     */
+    removeFromSearchMetadataBatch(collectionName: string, ids: Id[]): number;
+    /**
+     * Gets collection or throws an error if not found.
+     *
+     * @param name - Collection name
+     * @returns The collection
+     * @throws Error if collection is not found
+     * @internal
+     */
+    private getCollectionOrThrow;
+    /**
+     * Searches across all collections in the universe.
+     * Returns results grouped by collection name.
+     * For linked collections, returns combined results with their primary items.
+     * Only includes non-empty results.
+     *
+     * @param query - The search query string
+     * @param limit - Maximum number of results per collection (default: 10)
+     * @param opts - Search options for controlling match behavior and collection filtering
+     * @returns Object with collection names as keys and results as values.
+     *          Standalone collections: array of items
+     *          Linked collections: array of { linked: item, primary: primaryItem }
+     *
+     * @example
+     * ```typescript
+     * const results = universe.searchUniversally('krajnik');
+     * // Returns:
+     * // {
+     * //   stranke: [{ _id: 's1', name: 'Krajnik', ... }],
+     * //   pacienti: [{ linked: { _id: 'p1', ... }, primary: { _id: 's1', ... } }]
+     * // }
+     *
+     * // Filter to specific collections:
+     * const filtered = universe.searchUniversally('rex', 10, {
+     *   inCollections: ['pacienti-stranke', 'racuni-pacienti']
+     * });
+     * ```
+     */
+    searchUniversally(query: string, limit?: number, opts?: UniversalSearchOpts): Record<string, SearchableObject[] | Array<{
+        linked: SearchableObject[];
+        primary: SearchableObject;
+        matchedIn: 'primary' | 'linked' | 'both';
+    }>>;
+    /**
+     * Clears all collections, removing all data, metadata, and linked indexes.
+     *
+     * @example
+     * ```typescript
+     * universe.clear();
+     * // All collections are now empty, can re-register and reload
+     * ```
+     */
+    clear(): void;
+}
+//# sourceMappingURL=SearchUniverse.d.ts.map

package/dist/common/SearchUniverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchUniverse.d.ts","sourceRoot":"","sources":["../../src/common/SearchUniverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAEhB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAWlB,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAcvG;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,WAAW,CAAiC;IAEpD;;;;;OAKG;IACH,kBAAkB,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACxD,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAM,GAClC,IAAI;IAmBP;;;;;OAKG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;;;OAIG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,SAAS,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAsC1E;;;;;;;OAOG;IACH,OAAO,CAAC,CAAC,SAAS,gBAAgB,EAAE,cAAc,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,SAAS;IAKlF;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,SAAS,gBAAgB,EAAE,cAAc,EAAE,MAAM,GAAG,CAAC,EAAE;IAKjE;;;;;OAKG;IACH,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM;IAKjD;;;;;OAKG;IACH,WAAW,CAAC,cAAc,EAAE,MAAM,GAAG,qBAAqB;IAK1D;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,SAAS,gBAAgB,EAAE,cAAc,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC;IAK9E;;;;;;;OAOG;IACH,YAAY,CAAC,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,EAAE;IAQ/D;;;;;;;OAOG;IACH,cAAc,CAAC,CAAC,SAAS,gBAAgB,EACvC,oBAAoB,EAAE,MAAM,EAC5B,SAAS,EAAE,EAAE,GACZ,CAAC,EAAE;IAMN;;;;;;;;;;;;OAYG;IACH,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,EAC7C,cAAc,EAAE,MAAM,EACtB,EAAE,EAAE,EAAE,EACN,IAAI,EAAE,CAAC,GACN,YAAY;IAoFf;;;;;;OAMG;IACH,yBAAyB,CAAC,CAAC,SAAS,gBAAgB,EAClD,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,CAAC,EAAE,GACT,iBAAiB;IA0BpB;;;;;;OAMG;IACH,wBAAwB,CAAC,cAAc,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO;IAmCjE;;;;;;OAMG;IACH,6BAA6B,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,MAAM;IAcxE;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,iBAAiB,CACf,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,mBAAmB,GACzB,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC;QAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAC;QAAC,SAAS,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;IA8FlJ;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI;CAUd"}

package/dist/common/findInArray.d.ts

@@ -0,0 +1,37 @@
+import type { SearchMetadata, SearchableObject, SearchableData, SearchOpts } from '../types';
+/**
+ * Searches a data set using pre-computed metadata.
+ *
+ * This is the main search function for single collections. It tokenizes the query,
+ * matches all tokens against each item's metadata, and returns matching items.
+ *
+ * Use this function when you only need the matching items. If you also need
+ * the query tokens or item metadata, use {@link findInArrayReturnDataAndMeta} instead.
+ *
+ * @typeParam T - Type of items being searched
+ *
+ * @param query - The search query string (will be tokenized)
+ * @param data - Map of items by ID (SearchableData)
+ * @param metadata - Pre-computed search metadata (SearchMetadata)
+ * @param limit - Maximum number of results to return (default: 10)
+ * @param opts - Optional search options for controlling match behavior
+ * @returns Array of matching items (up to limit)
+ *
+ * @example
+ * ```typescript
+ * const products = arrayToSearchableData([
+ *   { _id: '1', name: 'Čokolada Milka', category: 'sladkarije' },
+ *   { _id: '2', name: 'Mleko Alpsko', category: 'mlečni izdelki' },
+ * ]);
+ *
+ * const metadata = createSearchArrayMetadata(products);
+ *
+ * findInArray('cokolada', products, metadata, 10);
+ * // Returns: [{ _id: '1', name: 'Čokolada Milka', ... }]
+ *
+ * findInArray('mleko', products, metadata, 10, { matchWords: 'whole' });
+ * // Returns: [{ _id: '2', name: 'Mleko Alpsko', ... }]
+ * ```
+ */
+export declare function findInArray<T extends SearchableObject>(query: string, data: SearchableData<T>, metadata: SearchMetadata, limit?: number, opts?: SearchOpts): T[];
+//# sourceMappingURL=findInArray.d.ts.map

package/dist/common/findInArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findInArray.d.ts","sourceRoot":"","sources":["../../src/common/findInArray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,gBAAgB,EACpD,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,cAAc,EACxB,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,CAAC,EAAE,CAGL"}

package/dist/common/findInArrayReturnDataAndMeta.d.ts

@@ -0,0 +1,52 @@
+import type { Id, SearchMetadata, SearchableObject, SearchableData, SearchOpts, SearchResultWithMeta } from '../types';
+export type { SearchResultWithMeta } from '../types';
+/**
+ * Searches a data set using pre-computed metadata and returns items with their tokens.
+ *
+ * This function is the core search implementation. It tokenizes the query,
+ * iterates through the metadata, and returns items where all query tokens
+ * match at least one item token (according to match mode rules).
+ *
+ * Use this function when you need access to the query tokens or item tokens
+ * (for debugging, highlighting, etc.). For simpler use cases, use {@link findInArray}.
+ *
+ * @typeParam T - Type of items being searched
+ *
+ * @param query - The search query string (will be tokenized)
+ * @param data - Map of items by ID (SearchableData)
+ * @param metadata - Pre-computed search metadata (SearchMetadata)
+ * @param limit - Maximum number of results to return (default: 10)
+ * @param opts - Optional search options for controlling match behavior
+ * @returns Search results including query tokens and matching items with their tokens
+ *
+ * @example
+ * ```typescript
+ * const result = findInArrayReturnDataAndMeta('john doe', data, metadata, 10);
+ *
+ * console.log(result.queryTokens);  // ['doe', 'john']
+ * console.log(result.results[0].item);  // { _id: '1', name: 'John Doe', ... }
+ * console.log(result.results[0].tokens);  // ['doe', 'john', ...]
+ * ```
+ */
+export declare function findInArrayReturnDataAndMeta<T extends SearchableObject>(query: string, data: SearchableData<T>, metadata: SearchMetadata, limit?: number, opts?: SearchOpts): SearchResultWithMeta<T>;
+/**
+ * Searches metadata and returns just the matching item IDs.
+ *
+ * This is a lightweight search function that doesn't fetch the full objects,
+ * only their IDs. Useful when you need to know what matches without loading
+ * all the data, or when you want to fetch items from a different source.
+ *
+ * @param query - The search query string (will be tokenized)
+ * @param metadata - Pre-computed search metadata (SearchMetadata)
+ * @param limit - Maximum number of results to return (default: 10)
+ * @param opts - Optional search options for controlling match behavior
+ * @returns Array of matching item IDs (up to limit)
+ *
+ * @example
+ * ```typescript
+ * const ids = findInArrayReturnIds('john', metadata, 10);
+ * // Returns: ['id1', 'id2', ...]
+ * ```
+ */
+export declare function findInArrayReturnIds(query: string, metadata: SearchMetadata, limit?: number, opts?: SearchOpts): Id[];
+//# sourceMappingURL=findInArrayReturnDataAndMeta.d.ts.map

package/dist/common/findInArrayReturnDataAndMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findInArrayReturnDataAndMeta.d.ts","sourceRoot":"","sources":["../../src/common/findInArrayReturnDataAndMeta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAKlB,YAAY,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,SAAS,gBAAgB,EACrE,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,cAAc,EACxB,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,oBAAoB,CAAC,CAAC,CAAC,CAkCzB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,cAAc,EACxB,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAoBN"}

package/dist/common/findInLinkedArrays.d.ts

@@ -0,0 +1,66 @@
+import type { SearchableObject, SearchOpts, LinkedSearchResult, LinkedSearchResultWithMeta, SearchLinkedMetadataWithData } from '../types';
+export type { LinkedSearchResult, LinkedSearchResultWithMeta } from '../types';
+/**
+ * Searches across linked data sets, matching against primary + all its linked items combined.
+ *
+ * For each primary item, collects all tokens from the primary and all its linked items,
+ * then matches query tokens against this combined pool. Returns primary items with
+ * only the linked items that contributed to the match.
+ *
+ * **Key behaviors:**
+ * - Tokens that match in the primary are excluded from linked matching (prevents
+ *   foreign key redundancy)
+ * - Only linked items that match ALL remaining tokens are included in results
+ * - `matchedIn` indicates where the match was found: 'primary', 'linked', or 'both'
+ *
+ * @typeParam TPrimary - Type of primary items (e.g., Stranka)
+ * @typeParam TLinked - Type of linked items (e.g., Pacient)
+ *
+ * @param query - The search query string (will be tokenized)
+ * @param linked - Linked metadata from {@link createSearchLinkedMetadata}
+ * @param limit - Maximum number of results to return (default: 10)
+ * @param opts - Optional search options for controlling match behavior
+ * @returns Search results with query tokens and matching items
+ *
+ * @example
+ * ```typescript
+ * const linkedMeta = createSearchLinkedMetadata(
+ *   strankeData, strankeMeta,
+ *   pacientiData, pacientiMeta,
+ *   (p) => p.stranka_id
+ * );
+ *
+ * // Search "krajnik angie" matches stranka "Krajnik" with pacient "Angie"
+ * const result = findInLinkedArrays('krajnik angie', linkedMeta, 10);
+ *
+ * console.log(result.results[0]);
+ * // {
+ * //   primary: { _id: 's1', ime: 'Janez', priimek: 'Krajnik' },
+ * //   linked: [{ _id: 'p1', ime: 'Angie', pasma: 'labrador' }],
+ * //   matchedIn: 'both'
+ * // }
+ * ```
+ */
+export declare function findInLinkedArrays<TPrimary extends SearchableObject, TLinked extends SearchableObject>(query: string, linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, limit?: number, opts?: SearchOpts): LinkedSearchResultWithMeta<TPrimary, TLinked>;
+/**
+ * Simplified version of {@link findInLinkedArrays} that returns just the results.
+ *
+ * Use this when you don't need the query tokens metadata.
+ *
+ * @typeParam TPrimary - Type of primary items (e.g., Stranka)
+ * @typeParam TLinked - Type of linked items (e.g., Pacient)
+ *
+ * @param query - The search query string (will be tokenized)
+ * @param linked - Linked metadata from {@link createSearchLinkedMetadata}
+ * @param limit - Maximum number of results to return (default: 10)
+ * @param opts - Optional search options for controlling match behavior
+ * @returns Array of matching results (without query tokens metadata)
+ *
+ * @example
+ * ```typescript
+ * const results = findInLinkedArraysSimple('krajnik', linkedMeta, 10);
+ * // Returns: [{ primary: Stranka, linked: [...], matchedIn: 'primary' }, ...]
+ * ```
+ */
+export declare function findInLinkedArraysSimple<TPrimary extends SearchableObject, TLinked extends SearchableObject>(query: string, linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, limit?: number, opts?: SearchOpts): LinkedSearchResult<TPrimary, TLinked>[];
+//# sourceMappingURL=findInLinkedArrays.d.ts.map

package/dist/common/findInLinkedArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findInLinkedArrays.d.ts","sourceRoot":"","sources":["../../src/common/findInLinkedArrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,UAAU,CAAC;AAKlB,YAAY,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EACvD,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,CAAC,CAyF/C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EACvD,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAEzC"}

package/dist/common/numeric/createSearchArrayMetadata.d.ts

@@ -0,0 +1,65 @@
+import type { MatchMode, NumericSearchMetadata, NumericTokenSortedList, SearchableObject, SearchableData, SearchableObjectSpec } from '../../types';
+/**
+ * Prefix characters for per-field match modes.
+ * Note: With numeric tokens, prefixes are encoded differently.
+ * High bits of token ID can encode the match mode.
+ */
+export declare const MATCH_MODE_BITS: Record<MatchMode, number>;
+/** Mask for extracting token ID (lower 29 bits) */
+export declare const TOKEN_ID_MASK: number;
+/**
+ * Encodes a token ID with a match mode.
+ * @param tokenId - The base token ID (must be < 2^29)
+ * @param mode - The match mode to encode
+ * @returns Encoded token with mode bits
+ */
+export declare function encodeTokenWithMode(tokenId: number, mode: MatchMode): number;
+/**
+ * Decodes a token to get the original token ID.
+ * @param encoded - The encoded token
+ * @returns The original token ID
+ */
+export declare function decodeTokenId(encoded: number): number;
+/**
+ * Decodes a token to get the match mode.
+ * @param encoded - The encoded token
+ * @returns The match mode (or 'start' as default if mode bits are 0)
+ */
+export declare function decodeMatchMode(encoded: number): MatchMode;
+/**
+ * Prepares an object for search, returning numeric token IDs.
+ *
+ * @param obj - The searchable object to prepare
+ * @param spec - Optional specification for extraction and match modes
+ * @param tokensMap - Map for string->number conversion
+ * @returns undefined if object is _deleted or _blocked, otherwise sorted Uint32Array
+ */
+export declare function prepareObjectForSearchNumeric<T extends SearchableObject, C = unknown>(obj: T, spec: SearchableObjectSpec<T, C> | undefined, tokensMap: Map<string, number>): NumericTokenSortedList | undefined;
+/**
+ * Creates numeric search metadata for a collection of items.
+ *
+ * Pre-processes all searchable text into sorted numeric token IDs.
+ * Items with `_deleted` or `_blocked` fields are automatically excluded.
+ *
+ * The tokensMap is created at the start and cleared after metadata creation
+ * to free memory. Only the global tokens array remains in memory.
+ *
+ * @param data - Map of items by ID (SearchableData)
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns NumericSearchMetadata map (Id → sorted Uint32Array of token IDs)
+ *
+ * @example
+ * ```typescript
+ * const items = arrayToSearchableData([
+ *   { _id: '1', name: 'John Doe', barcode: '123456' },
+ *   { _id: '2', name: 'Jane Smith', barcode: '789012' },
+ * ]);
+ *
+ * const metadata = createSearchArrayMetadataNumeric(items, {
+ *   searchInFields: ['name', 'barcode'],
+ *   fieldMatchModes: { barcode: 'startEnd' },
+ * });
+ * ```
+ */
+export declare function createSearchArrayMetadataNumeric<T extends SearchableObject, C = unknown>(data: SearchableData<T>, spec?: SearchableObjectSpec<T, C>): NumericSearchMetadata;
+//# sourceMappingURL=createSearchArrayMetadata.d.ts.map

package/dist/common/numeric/createSearchArrayMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/createSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACrB,MAAM,aAAa,CAAC;AASrB;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMrD,CAAC;AAKF,mDAAmD;AACnD,eAAO,MAAM,aAAa,QAAwB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAS1D;AAoED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACnF,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAC5C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,sBAAsB,GAAG,SAAS,CAgBpC;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACtF,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,qBAAqB,CAmBvB"}

package/dist/common/numeric/createSearchLinkedMetadata.d.ts

@@ -0,0 +1,46 @@
+import type { Id, NumericSearchMetadata, SearchableObject, SearchableData } from '../../types';
+/**
+ * Extended linked search metadata for numeric tokens.
+ */
+export interface NumericLinkedSearchMetadataWithData<TPrimary extends SearchableObject, TLinked extends SearchableObject> {
+    /** Metadata for primary items (numeric tokens) */
+    primaryMeta: NumericSearchMetadata;
+    /** Metadata for linked/secondary items (numeric tokens) */
+    linkedMeta: NumericSearchMetadata;
+    /** Index: primary._id -> linked._id[] */
+    primaryToLinked: Map<Id, Id[]>;
+    /** Reference to primary data map */
+    primaryData: SearchableData<TPrimary>;
+    /** Reference to linked data map */
+    linkedData: SearchableData<TLinked>;
+}
+/**
+ * Creates linked metadata for searching across two related data sets with numeric tokens.
+ *
+ * This function builds a reverse index from primary items to their linked items,
+ * enabling efficient combined searches.
+ *
+ * The tokensMap is NOT created here because the metadata is already numeric.
+ * This function only builds the primaryToLinked index.
+ *
+ * @typeParam TPrimary - Type of primary items (e.g., Stranka)
+ * @typeParam TLinked - Type of linked items (e.g., Pacient)
+ *
+ * @param primaryData - Primary data map (e.g., stranke)
+ * @param primaryMetadata - Pre-computed numeric metadata for primary items
+ * @param linkedData - Linked/secondary data map (e.g., pacienti)
+ * @param linkedMetadata - Pre-computed numeric metadata for linked items
+ * @param foreignKeyGetter - Function to extract the primary ID from a linked item
+ * @returns Linked metadata for combined searching
+ *
+ * @example
+ * ```typescript
+ * const linkedMeta = createSearchLinkedMetadataNumeric(
+ *   strankeData, strankeMeta,
+ *   pacientiData, pacientiMeta,
+ *   (pacient) => pacient.stranka_id
+ * );
+ * ```
+ */
+export declare function createSearchLinkedMetadataNumeric<TPrimary extends SearchableObject, TLinked extends SearchableObject>(primaryData: SearchableData<TPrimary>, primaryMetadata: NumericSearchMetadata, linkedData: SearchableData<TLinked>, linkedMetadata: NumericSearchMetadata, foreignKeyGetter: (linked: TLinked) => Id | undefined): NumericLinkedSearchMetadataWithData<TPrimary, TLinked>;
+//# sourceMappingURL=createSearchLinkedMetadata.d.ts.map

package/dist/common/numeric/createSearchLinkedMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSearchLinkedMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/createSearchLinkedMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACf,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,mCAAmC,CAClD,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB;IAEhC,kDAAkD;IAClD,WAAW,EAAE,qBAAqB,CAAC;IACnC,2DAA2D;IAC3D,UAAU,EAAE,qBAAqB,CAAC;IAClC,yCAAyC;IACzC,eAAe,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/B,oCAAoC;IACpC,WAAW,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IACtC,mCAAmC;IACnC,UAAU,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,WAAW,EAAE,cAAc,CAAC,QAAQ,CAAC,EACrC,eAAe,EAAE,qBAAqB,EACtC,UAAU,EAAE,cAAc,CAAC,OAAO,CAAC,EACnC,cAAc,EAAE,qBAAqB,EACrC,gBAAgB,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,GAAG,SAAS,GACpD,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,CAoBxD"}

package/dist/common/numeric/findInLinkedArrays.d.ts

@@ -0,0 +1,32 @@
+import type { SearchableObject, SearchOpts, LinkedSearchResult, LinkedSearchResultWithMeta } from '../../types';
+import type { NumericLinkedSearchMetadataWithData } from './createSearchLinkedMetadata';
+/**
+ * Searches across linked data sets using numeric tokens.
+ *
+ * For each primary item, collects all tokens from the primary and all its linked items,
+ * then matches query tokens against this combined pool. Returns primary items with
+ * only the linked items that contributed to the match.
+ *
+ * **Key behaviors:**
+ * - Tokens that match in the primary are excluded from linked matching (prevents
+ *   foreign key redundancy)
+ * - Only linked items that match ALL remaining tokens are included in results
+ * - `matchedIn` indicates where the match was found: 'primary', 'linked', or 'both'
+ *
+ * @typeParam TPrimary - Type of primary items (e.g., Stranka)
+ * @typeParam TLinked - Type of linked items (e.g., Pacient)
+ *
+ * @param query - The search query string (will be tokenized)
+ * @param linked - Linked metadata from {@link createSearchLinkedMetadataNumeric}
+ * @param limit - Maximum number of results to return (default: 10)
+ * @param opts - Optional search options for controlling match behavior
+ * @returns Search results with query tokens and matching items
+ */
+export declare function findInLinkedArraysNumeric<TPrimary extends SearchableObject, TLinked extends SearchableObject>(query: string, linked: NumericLinkedSearchMetadataWithData<TPrimary, TLinked>, limit?: number, opts?: SearchOpts): LinkedSearchResultWithMeta<TPrimary, TLinked>;
+/**
+ * Simplified version of {@link findInLinkedArraysNumeric} that returns just the results.
+ *
+ * Use this when you don't need the query tokens metadata.
+ */
+export declare function findInLinkedArraysSimpleNumeric<TPrimary extends SearchableObject, TLinked extends SearchableObject>(query: string, linked: NumericLinkedSearchMetadataWithData<TPrimary, TLinked>, limit?: number, opts?: SearchOpts): LinkedSearchResult<TPrimary, TLinked>[];
+//# sourceMappingURL=findInLinkedArrays.d.ts.map

package/dist/common/numeric/findInLinkedArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findInLinkedArrays.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/findInLinkedArrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,8BAA8B,CAAC;AAQxF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAC9D,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,CAAC,CAyJ/C;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAC9D,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAEzC"}

package/dist/common/numeric/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Numeric token implementation - memory-optimized search using Uint32Array
+ */
+export { createSearchArrayMetadataNumeric, prepareObjectForSearchNumeric, encodeTokenWithMode, decodeTokenId, decodeMatchMode, TOKEN_ID_MASK, MATCH_MODE_BITS, } from './createSearchArrayMetadata';
+export { createSearchLinkedMetadataNumeric, type NumericLinkedSearchMetadataWithData, } from './createSearchLinkedMetadata';
+export { updateSearchMetadataNumeric, updateSearchMetadataBatchNumeric, removeFromSearchMetadataNumeric, removeFromSearchMetadataBatchNumeric, } from './updateSearchMetadata';
+export { searchInDataReturnIdsNumeric, searchInDataReturnObjectsNumeric, searchInDataReturnIdsWithLimitNumeric, } from './searchInData';
+export { findInLinkedArraysNumeric, findInLinkedArraysSimpleNumeric, } from './findInLinkedArrays';
+//# sourceMappingURL=index.d.ts.map

package/dist/common/numeric/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,gCAAgC,EAChC,6BAA6B,EAC7B,mBAAmB,EACnB,aAAa,EACb,eAAe,EACf,aAAa,EACb,eAAe,GAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,iCAAiC,EACjC,KAAK,mCAAmC,GACzC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,EAChC,+BAA+B,EAC/B,oCAAoC,GACrC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,4BAA4B,EAC5B,gCAAgC,EAChC,qCAAqC,GACtC,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,yBAAyB,EACzB,+BAA+B,GAChC,MAAM,sBAAsB,CAAC"}

package/dist/common/numeric/searchInData.d.ts

@@ -0,0 +1,31 @@
+import type { Id, NumericSearchMetadata, SearchableData, SearchableObject, SearchOpts } from '../../types';
+/**
+ * Searches in numeric metadata and returns matching IDs.
+ *
+ * @param query - The search query string
+ * @param metadata - The NumericSearchMetadata to search in
+ * @param opts - Optional search options for match mode
+ * @returns Array of matching object IDs
+ */
+export declare function searchInDataReturnIdsNumeric(query: string, metadata: NumericSearchMetadata, opts?: SearchOpts): Id[];
+/**
+ * Searches in numeric metadata and returns matching objects.
+ *
+ * @param query - The search query string
+ * @param metadata - The NumericSearchMetadata to search in
+ * @param data - The SearchableData map for object lookup
+ * @param opts - Optional search options for match mode
+ * @returns Map of matching objects by ID
+ */
+export declare function searchInDataReturnObjectsNumeric<T extends SearchableObject>(query: string, metadata: NumericSearchMetadata, data: SearchableData<T>, opts?: SearchOpts): Map<Id, T>;
+/**
+ * Searches with a limit and returns matching IDs.
+ *
+ * @param query - The search query string
+ * @param metadata - The NumericSearchMetadata to search in
+ * @param limit - Maximum number of results to return
+ * @param opts - Optional search options for match mode
+ * @returns Array of matching object IDs (up to limit)
+ */
+export declare function searchInDataReturnIdsWithLimitNumeric(query: string, metadata: NumericSearchMetadata, limit: number, opts?: SearchOpts): Id[];
+//# sourceMappingURL=searchInData.d.ts.map

package/dist/common/numeric/searchInData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchInData.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/searchInData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,UAAU,EACX,MAAM,aAAa,CAAC;AAIrB;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAoBN;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EACzE,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,UAAU,GAChB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAYZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAsBN"}