cry-search 1.0.0

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

@@ -0,0 +1,60 @@
+import type { Id, NumericSearchMetadata, SearchableObject, SearchableObjectSpec, UpdateSearchMetadataBatchItem } from '../../types';
+/**
+ * Updates numeric search metadata for a single object.
+ *
+ * This function handles updates, additions, and removals:
+ * - If the object is `null` or `undefined`, removes it from metadata
+ * - If the object is `_deleted` or `_blocked`, removes it from metadata
+ * - Otherwise, computes new tokens and updates/adds to metadata
+ *
+ * @param metadata - The NumericSearchMetadata map to update (mutated in place)
+ * @param objectId - The ID of the object to update
+ * @param obj - The object (may be null, undefined, deleted, or blocked)
+ * @param spec - Optional specification for how to extract searchable text
+ * @param tokensMap - Map for string->number conversion
+ * @returns true if metadata was added/updated, false if removed
+ */
+export declare function updateSearchMetadataNumeric<T extends SearchableObject, C = unknown>(metadata: NumericSearchMetadata, objectId: Id, obj: T | null | undefined, spec: SearchableObjectSpec<T, C> | undefined, tokensMap: Map<string, number>): boolean;
+/**
+ * Updates numeric search metadata for multiple objects in a batch.
+ *
+ * Creates a temporary tokensMap for the duration of the batch operation,
+ * then clears it after use to free memory.
+ *
+ * @param metadata - The NumericSearchMetadata map to update (mutated in place)
+ * @param batch - Array of objects to update
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns Object with counts of added/updated and removed items
+ *
+ * @example
+ * ```typescript
+ * const batch = [
+ *   { objectId: '1', obj: { _id: '1', name: 'Product 1' } },
+ *   { objectId: '2', obj: { _id: '2', name: 'Product 2', _deleted: new Date() } },
+ * ];
+ *
+ * const result = updateSearchMetadataBatchNumeric(metadata, batch, spec);
+ * // result: { updated: 1, removed: 1 }
+ * ```
+ */
+export declare function updateSearchMetadataBatchNumeric<T extends SearchableObject, C = unknown>(metadata: NumericSearchMetadata, batch: UpdateSearchMetadataBatchItem<T>[], spec?: SearchableObjectSpec<T, C>): {
+    updated: number;
+    removed: number;
+};
+/**
+ * Removes an object from numeric search metadata by ID.
+ *
+ * @param metadata - The NumericSearchMetadata map to update (mutated in place)
+ * @param objectId - The ID of the object to remove
+ * @returns true if the object was found and removed, false if it wasn't in metadata
+ */
+export declare function removeFromSearchMetadataNumeric(metadata: NumericSearchMetadata, objectId: Id): boolean;
+/**
+ * Removes multiple objects from numeric search metadata by IDs.
+ *
+ * @param metadata - The NumericSearchMetadata map to update (mutated in place)
+ * @param objectIds - Array of IDs to remove
+ * @returns Number of objects that were actually removed
+ */
+export declare function removeFromSearchMetadataBatchNumeric(metadata: NumericSearchMetadata, objectIds: Id[]): number;
+//# sourceMappingURL=updateSearchMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"updateSearchMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/updateSearchMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,6BAA6B,EAC9B,MAAM,aAAa,CAAC;AAIrB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACjF,QAAQ,EAAE,qBAAqB,EAC/B,QAAQ,EAAE,EAAE,EACZ,GAAG,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EACzB,IAAI,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAC5C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,OAAO,CAUT;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACtF,QAAQ,EAAE,qBAAqB,EAC/B,KAAK,EAAE,6BAA6B,CAAC,CAAC,CAAC,EAAE,EACzC,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA0BtC;AAED;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,qBAAqB,EAC/B,QAAQ,EAAE,EAAE,GACX,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,qBAAqB,EAC/B,SAAS,EAAE,EAAE,EAAE,GACd,MAAM,CAYR"}

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

@@ -0,0 +1,117 @@
+import type { MatchMode, SearchMetadata, SearchableObject, SearchableData, SearchableObjectSpec, SearchTokenSortedList, SearchArrayMetadata } from '../../types';
+/**
+ * Prefix characters for per-field match modes.
+ * Tokens with these prefixes use the specified mode instead of global SearchOpts.
+ */
+export declare const MATCH_MODE_PREFIXES: Record<MatchMode, string>;
+/**
+ * Reverse mapping from prefix to match mode.
+ */
+export declare const PREFIX_TO_MATCH_MODE: Record<string, MatchMode>;
+/**
+ * Checks if an object is deleted or blocked and should be excluded from search.
+ *
+ * Objects with `_deleted` or `_blocked` fields set are excluded from search results.
+ *
+ * @param obj - The searchable object to check
+ * @returns True if the object has _deleted or _blocked set
+ *
+ * @example
+ * ```typescript
+ * isDeletedOrBlocked({ _id: '1', name: 'Test' })                    // false
+ * isDeletedOrBlocked({ _id: '1', name: 'Test', _deleted: new Date() }) // true
+ * ```
+ */
+export declare function isDeletedOrBlocked(obj: SearchableObject): boolean;
+/**
+ * Default function to extract searchable string from an object.
+ *
+ * Concatenates all string/number values from specified fields (or all fields if not specified).
+ * System fields (_id, _deleted, _blocked) are excluded by default.
+ * Supports dot notation paths for nested fields (e.g., 'customer.firstName').
+ * Recursively extracts values from nested objects and arrays.
+ *
+ * @param obj - The searchable object to extract text from
+ * @param spec - Optional specification for field extraction
+ * @returns undefined if object is _deleted or _blocked, otherwise the searchable string
+ *
+ * @example
+ * ```typescript
+ * const obj = { _id: '1', name: 'John', age: 30 };
+ * extractSearchableStringDefault(obj)
+ * // Returns: 'John 30'
+ *
+ * const obj2 = { _id: '1', customer: { firstName: 'John' } };
+ * extractSearchableStringDefault(obj2, { searchInFields: ['customer.firstName'] })
+ * // Returns: 'John'
+ * ```
+ */
+export declare function extractSearchableStringDefault<T extends SearchableObject, C = unknown>(obj: T, spec?: SearchableObjectSpec<T, C>): string | undefined;
+/**
+ * Prepares an object for search by extracting searchable text and tokenizing it.
+ *
+ * If `fieldMatchModes` is specified in the spec, tokens from those fields will have
+ * match mode prefixes (e.g., `!` for whole, `+` for startEnd).
+ *
+ * Supports dot notation in `searchInFields` for targeting specific nested fields.
+ * Recursively extracts values from nested objects and arrays.
+ *
+ * @param obj - The searchable object to prepare
+ * @param spec - Optional specification for extraction and match modes
+ * @returns undefined if object is _deleted or _blocked, otherwise sorted token list
+ *
+ * @example
+ * ```typescript
+ * const obj = { _id: '1', name: 'John Doe', barcode: '123456' };
+ * prepareObjectForSearch(obj, {
+ *   searchInFields: ['name', 'barcode'],
+ *   fieldMatchModes: { barcode: 'whole' }
+ * })
+ * // Returns: ['!123456', 'doe', 'john']
+ * ```
+ */
+export declare function prepareObjectForSearch<T extends SearchableObject, C = unknown>(obj: T, spec?: SearchableObjectSpec<T, C>): SearchTokenSortedList | undefined;
+/**
+ * Creates search metadata for a collection of items.
+ *
+ * Pre-processes all searchable text into sorted tokens for fast searching.
+ * Items with `_deleted` or `_blocked` fields are automatically excluded.
+ *
+ * @param data - Map of items by ID (SearchableData)
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns SearchMetadata map (Id → sorted tokens)
+ *
+ * @example
+ * ```typescript
+ * const items = arrayToSearchableData([
+ *   { _id: '1', name: 'John Doe', barcode: '123456' },
+ *   { _id: '2', name: 'Jane Smith', barcode: '789012' },
+ * ]);
+ *
+ * const metadata = createSearchArrayMetadata(items, {
+ *   searchInFields: ['name', 'barcode'],
+ *   fieldMatchModes: { barcode: 'startEnd' },
+ * });
+ *
+ * // metadata.get('1') → ['+123456', 'doe', 'john']
+ * ```
+ */
+export declare function createSearchArrayMetadata<T extends SearchableObject, C = unknown>(data: SearchableData<T>, spec?: SearchableObjectSpec<T, C>): SearchMetadata;
+export type { SearchMetadata, SearchableObject, SearchableData, SearchableObjectSpec, SearchArrayMetadata, SearchableItem, SearchItemMetadata, } from '../../types';
+/**
+ * Helper to wrap new SearchMetadata in legacy SearchArrayMetadata format.
+ *
+ * @param metadata - The SearchMetadata to wrap
+ * @returns Legacy SearchArrayMetadata object
+ * @deprecated Use SearchMetadata directly instead
+ */
+export declare function wrapMetadataLegacy(metadata: SearchMetadata): SearchArrayMetadata;
+/**
+ * Helper to unwrap legacy SearchArrayMetadata to new SearchMetadata format.
+ *
+ * @param legacy - The legacy SearchArrayMetadata to unwrap
+ * @returns The SearchMetadata map
+ * @deprecated Use SearchMetadata directly instead
+ */
+export declare function unwrapMetadataLegacy(legacy: SearchArrayMetadata): SearchMetadata;
+//# sourceMappingURL=createSearchArrayMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/string/createSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAGrB;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMzD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAS1D,CAAC;AAmHF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACpF,GAAG,EAAE,CAAC,EACN,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,MAAM,GAAG,SAAS,CA8BpB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAC5E,GAAG,EAAE,CAAC,EACN,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,qBAAqB,GAAG,SAAS,CAkBnC;AAgFD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAC/E,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,cAAc,CAYhB;AAGD,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,GAAG,mBAAmB,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,cAAc,CAEhF"}

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

@@ -0,0 +1,36 @@
+import type { Id, SearchMetadata, SearchableObject, SearchableData, SearchLinkedMetadataWithData } from '../../types';
+export type { SearchLinkedMetadataWithData } from '../../types';
+/**
+ * Creates linked metadata for searching across two related data sets.
+ *
+ * This function builds a reverse index from primary items to their linked items,
+ * enabling efficient combined searches (e.g., searching for "Krajnik Rex" finds
+ * the customer "Krajnik" with pet "Rex").
+ *
+ * The linked items are associated with primary items via a foreign key (e.g., `stranka_id`).
+ * No data is duplicated - the function stores references and indexes only.
+ *
+ * @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 metadata for primary items
+ * @param linkedData - Linked/secondary data map (e.g., pacienti)
+ * @param linkedMetadata - Pre-computed 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 = createSearchLinkedMetadata(
+ *   strankeData, strankeMeta,
+ *   pacientiData, pacientiMeta,
+ *   (pacient) => pacient.stranka_id
+ * );
+ *
+ * // Now use findInLinkedArrays to search across both collections
+ * const results = findInLinkedArrays('krajnik rex', linkedMeta, 10);
+ * ```
+ */
+export declare function createSearchLinkedMetadata<TPrimary extends SearchableObject, TLinked extends SearchableObject>(primaryData: SearchableData<TPrimary>, primaryMetadata: SearchMetadata, linkedData: SearchableData<TLinked>, linkedMetadata: SearchMetadata, foreignKeyGetter: (linked: TLinked) => Id | undefined): SearchLinkedMetadataWithData<TPrimary, TLinked>;
+//# sourceMappingURL=createSearchLinkedMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSearchLinkedMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/string/createSearchLinkedMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,4BAA4B,EAC7B,MAAM,aAAa,CAAC;AAGrB,YAAY,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,WAAW,EAAE,cAAc,CAAC,QAAQ,CAAC,EACrC,eAAe,EAAE,cAAc,EAC/B,UAAU,EAAE,cAAc,CAAC,OAAO,CAAC,EACnC,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,GAAG,SAAS,GACpD,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,CAoBjD"}

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

@@ -0,0 +1,10 @@
+/**
+ * String token implementation - original string-based search
+ */
+export { createSearchArrayMetadata, prepareObjectForSearch, extractSearchableStringDefault, isDeletedOrBlocked, MATCH_MODE_PREFIXES, PREFIX_TO_MATCH_MODE, wrapMetadataLegacy, unwrapMetadataLegacy, } from './createSearchArrayMetadata';
+export { createSearchLinkedMetadata, } from './createSearchLinkedMetadata';
+export { updateSearchMetadata, updateSearchMetadataBatch, removeFromSearchMetadata, removeFromSearchMetadataBatch, } from './updateSearchMetadata';
+export type { SearchMetadata, SearchableObject, SearchableData, SearchableObjectSpec, SearchArrayMetadata, SearchableItem, SearchItemMetadata, } from './createSearchArrayMetadata';
+export type { SearchLinkedMetadataWithData } from './createSearchLinkedMetadata';
+export type { UpdateSearchMetadataBatchItem } from './updateSearchMetadata';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/string/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,EACxB,6BAA6B,GAC9B,MAAM,wBAAwB,CAAC;AAGhC,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,GACnB,MAAM,6BAA6B,CAAC;AAErC,YAAY,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AACjF,YAAY,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/common/string/updateSearchMetadata.d.ts

@@ -0,0 +1,103 @@
+import type { Id, SearchMetadata, SearchableObject, SearchableObjectSpec, UpdateSearchMetadataBatchItem } from '../../types';
+export type { UpdateSearchMetadataBatchItem } from '../../types';
+/**
+ * Updates search metadata for a single object.
+ *
+ * This function handles updates, additions, and removals:
+ * - If the object is `null` or `undefined`, removes it from metadata
+ * - If the object is `_deleted` or `_blocked`, removes it from metadata
+ * - Otherwise, computes new tokens and updates/adds to metadata
+ *
+ * The metadata map is mutated in place for efficiency.
+ *
+ * @typeParam T - Type of the searchable object
+ * @typeParam C - Type of the search context
+ *
+ * @param metadata - The SearchMetadata map to update (mutated in place)
+ * @param objectId - The ID of the object to update
+ * @param obj - The object (may be null, undefined, deleted, or blocked)
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns true if metadata was added/updated, false if removed
+ *
+ * @example
+ * ```typescript
+ * // Update an existing item
+ * const product = { _id: '1', name: 'Updated Product' };
+ * updateSearchMetadata(metadata, '1', product, spec);
+ *
+ * // Mark an item as deleted (removes from search)
+ * const deletedProduct = { _id: '1', name: 'Product', _deleted: new Date() };
+ * updateSearchMetadata(metadata, '1', deletedProduct, spec);  // returns false
+ *
+ * // Remove by passing null/undefined
+ * updateSearchMetadata(metadata, '1', null, spec);  // returns false
+ * ```
+ */
+export declare function updateSearchMetadata<T extends SearchableObject, C = unknown>(metadata: SearchMetadata, objectId: Id, obj: T | null | undefined, spec?: SearchableObjectSpec<T, C>): boolean;
+/**
+ * Updates search metadata for multiple objects in a batch.
+ *
+ * More efficient than calling {@link updateSearchMetadata} repeatedly
+ * when you have multiple objects to update at once.
+ *
+ * - For objects that are `_deleted` or `_blocked`, removes them from metadata
+ * - For other objects, updates or adds their tokens to metadata
+ *
+ * @typeParam T - Type of the searchable objects
+ * @typeParam C - Type of the search context
+ *
+ * @param metadata - The SearchMetadata map to update (mutated in place)
+ * @param batch - Array of objects to update
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns Object with counts of added/updated and removed items
+ *
+ * @example
+ * ```typescript
+ * const batch = [
+ *   { objectId: '1', obj: { _id: '1', name: 'Product 1' } },
+ *   { objectId: '2', obj: { _id: '2', name: 'Product 2', _deleted: new Date() } },
+ * ];
+ *
+ * const result = updateSearchMetadataBatch(metadata, batch, spec);
+ * // result: { updated: 1, removed: 1 }
+ * ```
+ */
+export declare function updateSearchMetadataBatch<T extends SearchableObject, C = unknown>(metadata: SearchMetadata, batch: UpdateSearchMetadataBatchItem<T>[], spec?: SearchableObjectSpec<T, C>): {
+    updated: number;
+    removed: number;
+};
+/**
+ * Removes an object from search metadata by ID.
+ *
+ * Use this when you want to explicitly remove an object without having the full object.
+ * For updates where you have the object (including deleting by setting `_deleted`),
+ * use {@link updateSearchMetadata} instead.
+ *
+ * @param metadata - The SearchMetadata map to update (mutated in place)
+ * @param objectId - The ID of the object to remove
+ * @returns true if the object was found and removed, false if it wasn't in metadata
+ *
+ * @example
+ * ```typescript
+ * removeFromSearchMetadata(metadata, 'object-id-to-remove');
+ * ```
+ */
+export declare function removeFromSearchMetadata(metadata: SearchMetadata, objectId: Id): boolean;
+/**
+ * Removes multiple objects from search metadata by IDs.
+ *
+ * More efficient than calling {@link removeFromSearchMetadata} repeatedly
+ * when you have multiple IDs to remove.
+ *
+ * @param metadata - The SearchMetadata map to update (mutated in place)
+ * @param objectIds - Array of IDs to remove
+ * @returns Number of objects that were actually removed (may be less than objectIds.length)
+ *
+ * @example
+ * ```typescript
+ * const removed = removeFromSearchMetadataBatch(metadata, ['id1', 'id2', 'id3']);
+ * console.log(`Removed ${removed} items from metadata`);
+ * ```
+ */
+export declare function removeFromSearchMetadataBatch(metadata: SearchMetadata, objectIds: Id[]): number;
+//# sourceMappingURL=updateSearchMetadata.d.ts.map

package/dist/common/string/updateSearchMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateSearchMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/string/updateSearchMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,6BAA6B,EAC9B,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAC1E,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,EAAE,EACZ,GAAG,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EACzB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,OAAO,CAYT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAC/E,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,6BAA6B,CAAC,CAAC,CAAC,EAAE,EACzC,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAkBtC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,EAAE,GACX,OAAO,CAET;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,EAAE,EAAE,GACd,MAAM,CAYR"}

package/dist/common/syncSearchArrayMetadata.d.ts

@@ -0,0 +1,64 @@
+import type { SearchMetadata, SearchableData, SearchableObject, SearchableObjectSpec, SyncResult, SyncOptions } from '../types';
+export type { SyncResult, SyncOptions } from '../types';
+/**
+ * Syncs search metadata with new data.
+ *
+ * This function performs a full sync of metadata against the provided data:
+ * - Adds metadata for new items
+ * - Removes metadata for items no longer in data (or marked `_deleted`/`_blocked`)
+ * - Updates metadata for items whose tokens have changed
+ *
+ * Use this when you have completely new data to sync with. If you have both
+ * previous and new data available, use {@link syncSearchArrayMetadataWithPrevious}
+ * for more efficient diffing.
+ *
+ * @typeParam T - Type of the searchable objects
+ * @typeParam C - Type of the search context
+ *
+ * @param metadata - The SearchMetadata map to update (mutated in place)
+ * @param newData - The new data to sync with
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns SyncResult with counts and IDs of added/updated/removed items
+ *
+ * @example
+ * ```typescript
+ * const newProducts = arrayToSearchableData(freshProductsFromServer);
+ * const result = syncSearchArrayMetadata(metadata, newProducts, spec);
+ *
+ * console.log(`Added: ${result.added}, Updated: ${result.updated}, Removed: ${result.removed}`);
+ * ```
+ */
+export declare function syncSearchArrayMetadata<T extends SearchableObject, C = unknown>(metadata: SearchMetadata, newData: SearchableData<T>, spec?: SearchableObjectSpec<T, C>): SyncResult;
+/**
+ * Syncs search metadata using previous and new data for efficient diffing.
+ *
+ * More efficient than {@link syncSearchArrayMetadata} when you have both the
+ * previous and new data available. Uses the previous data to determine
+ * what was removed without iterating through all metadata keys.
+ *
+ * @typeParam T - Type of the searchable objects
+ * @typeParam C - Type of the search context
+ *
+ * @param metadata - The SearchMetadata map to update (mutated in place)
+ * @param previousData - The previous data (used to determine what was removed)
+ * @param newData - The new data to sync with
+ * @param options - Optional sync options (e.g., skipUpdateCheck)
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns SyncResult with counts and IDs of added/updated/removed items
+ *
+ * @example
+ * ```typescript
+ * const previousProducts = currentData;
+ * const newProducts = arrayToSearchableData(freshProductsFromServer);
+ *
+ * const result = syncSearchArrayMetadataWithPrevious(
+ *   metadata,
+ *   previousProducts,
+ *   newProducts,
+ *   { skipUpdateCheck: false },
+ *   spec
+ * );
+ * ```
+ */
+export declare function syncSearchArrayMetadataWithPrevious<T extends SearchableObject, C = unknown>(metadata: SearchMetadata, previousData: SearchableData<T>, newData: SearchableData<T>, options?: SyncOptions, spec?: SearchableObjectSpec<T, C>): SyncResult;
+//# sourceMappingURL=syncSearchArrayMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"syncSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../src/common/syncSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EAEpB,UAAU,EACV,WAAW,EACZ,MAAM,UAAU,CAAC;AAIlB,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAkBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAC7E,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,UAAU,CAiDZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,mCAAmC,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACzF,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC,EAC/B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,WAAW,EACrB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,UAAU,CAmDZ"}

package/dist/common/updateSearchLinkedMetadata.d.ts

@@ -0,0 +1,129 @@
+import type { Id, SearchableData, SearchableObject, SearchableObjectSpec, SearchLinkedMetadataWithData, UpsertResult, SyncLinkedResult } from '../types';
+export type { UpsertResult, SyncLinkedResult } from '../types';
+/**
+ * Upserts a primary item into the linked metadata.
+ *
+ * - If the item doesn't exist, adds it to data, metadata, and initializes primaryToLinked index
+ * - If the item exists, updates data and metadata
+ * - Handles `_deleted`/`_blocked` items by removing their metadata
+ *
+ * @typeParam TPrimary - Type of primary items
+ * @typeParam TLinked - Type of linked items
+ * @typeParam C - Type of the search context
+ *
+ * @param linked - The linked metadata to update (mutated in place)
+ * @param item - The primary item to upsert
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns UpsertResult indicating if item was added or updated
+ *
+ * @example
+ * ```typescript
+ * const stranka = { _id: 's1', ime: 'Janez', priimek: 'Novak' };
+ * const result = upsertPrimaryItem(linkedMeta, stranka, spec);
+ * // result.added === true if stranka was new
+ * ```
+ */
+export declare function upsertPrimaryItem<TPrimary extends SearchableObject, TLinked extends SearchableObject, C = unknown>(linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, item: TPrimary, spec?: SearchableObjectSpec<TPrimary, C>): UpsertResult;
+/**
+ * Removes a primary item from the linked metadata.
+ *
+ * Removes the item from data, metadata, and the primaryToLinked index.
+ * Note: This does NOT automatically remove linked items - they will become orphans.
+ * If you want to also remove linked items, call {@link removeLinkedItem} for each.
+ *
+ * @typeParam TPrimary - Type of primary items
+ * @typeParam TLinked - Type of linked items
+ *
+ * @param linked - The linked metadata to update (mutated in place)
+ * @param primaryId - The ID of the primary item to remove
+ * @returns true if item was found and removed, false if not found
+ */
+export declare function removePrimaryItem<TPrimary extends SearchableObject, TLinked extends SearchableObject>(linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, primaryId: Id): boolean;
+/**
+ * Upserts a linked item into the linked metadata.
+ *
+ * - If the item doesn't exist, adds it
+ * - If the item exists, updates it
+ * - Handles foreign key changes by updating the primaryToLinked index
+ *   (removes from old primary's list, adds to new primary's list)
+ * - Handles `_deleted`/`_blocked` items by removing their metadata
+ *
+ * @typeParam TPrimary - Type of primary items
+ * @typeParam TLinked - Type of linked items
+ * @typeParam C - Type of the search context
+ *
+ * @param linked - The linked metadata to update (mutated in place)
+ * @param item - The linked item to upsert
+ * @param foreignKeyGetter - Function to get the primary ID from a linked item
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns UpsertResult indicating if item was added or updated, and previous primary ID if FK changed
+ *
+ * @example
+ * ```typescript
+ * const pacient = { _id: 'p1', ime: 'Rex', stranka_id: 's1' };
+ * const result = upsertLinkedItem(linkedMeta, pacient, (p) => p.stranka_id, spec);
+ *
+ * // If the pacient moved to a different stranka:
+ * pacient.stranka_id = 's2';
+ * const result2 = upsertLinkedItem(linkedMeta, pacient, (p) => p.stranka_id, spec);
+ * // result2.previousPrimaryId === 's1'
+ * ```
+ */
+export declare function upsertLinkedItem<TPrimary extends SearchableObject, TLinked extends SearchableObject, C = unknown>(linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, item: TLinked, foreignKeyGetter: (item: TLinked) => Id | undefined, spec?: SearchableObjectSpec<TLinked, C>): UpsertResult;
+/**
+ * Removes a linked item from the linked metadata.
+ *
+ * Removes the item from data, metadata, and the primaryToLinked index.
+ *
+ * @typeParam TPrimary - Type of primary items
+ * @typeParam TLinked - Type of linked items
+ *
+ * @param linked - The linked metadata to update (mutated in place)
+ * @param linkedId - The ID of the linked item to remove
+ * @param foreignKeyGetter - Function to get the primary ID from a linked item
+ * @returns true if item was found and removed, false if not found
+ *
+ * @example
+ * ```typescript
+ * removeLinkedItem(linkedMeta, 'pacient-id', (p) => p.stranka_id);
+ * ```
+ */
+export declare function removeLinkedItem<TPrimary extends SearchableObject, TLinked extends SearchableObject>(linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, linkedId: Id, foreignKeyGetter: (item: TLinked) => Id | undefined): boolean;
+/**
+ * Syncs all linked items for a specific primary item.
+ *
+ * This function performs a full sync of linked items belonging to a single primary:
+ * - Removes linked items that are no longer in the new data
+ * - Updates existing linked items if their tokens changed
+ * - Adds new linked items
+ * - Only processes items whose foreign key points to the given primary
+ *
+ * Use this when you have a complete new set of linked items for a primary
+ * and want to update the metadata to match.
+ *
+ * @typeParam TPrimary - Type of primary items
+ * @typeParam TLinked - Type of linked items
+ * @typeParam C - Type of the search context
+ *
+ * @param linked - The linked metadata to update (mutated in place)
+ * @param primaryId - The primary ID to sync linked items for
+ * @param newLinkedItems - The new linked items (only items with matching FK will be processed)
+ * @param foreignKeyGetter - Function to get the primary ID from a linked item
+ * @param spec - Optional specification for how to extract searchable text
+ * @returns SyncLinkedResult with counts of added/updated/removed items
+ *
+ * @example
+ * ```typescript
+ * const newPacienti = arrayToSearchableData(freshPacientiFromServer);
+ * const result = syncLinkedItemsForPrimary(
+ *   linkedMeta,
+ *   'stranka-1',
+ *   newPacienti,
+ *   (p) => p.stranka_id,
+ *   spec
+ * );
+ * console.log(`Added: ${result.added}, Updated: ${result.updated}, Removed: ${result.removed}`);
+ * ```
+ */
+export declare function syncLinkedItemsForPrimary<TPrimary extends SearchableObject, TLinked extends SearchableObject, C = unknown>(linked: SearchLinkedMetadataWithData<TPrimary, TLinked>, primaryId: Id, newLinkedItems: SearchableData<TLinked>, foreignKeyGetter: (item: TLinked) => Id | undefined, spec?: SearchableObjectSpec<TLinked, C>): SyncLinkedResult;
+//# sourceMappingURL=updateSearchLinkedMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"updateSearchLinkedMetadata.d.ts","sourceRoot":"","sources":["../../src/common/updateSearchLinkedMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,4BAA4B,EAC5B,YAAY,EACZ,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAIlB,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAkB/D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAChC,CAAC,GAAG,OAAO,EAEX,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EACvD,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE,oBAAoB,CAAC,QAAQ,EAAE,CAAC,CAAC,GACvC,YAAY,CAqBd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAChC,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,EAAE,GAAG,OAAO,CAUjF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAChC,CAAC,GAAG,OAAO,EAEX,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EACvD,IAAI,EAAE,OAAO,EACb,gBAAgB,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,EAAE,GAAG,SAAS,EACnD,IAAI,CAAC,EAAE,oBAAoB,CAAC,OAAO,EAAE,CAAC,CAAC,GACtC,YAAY,CAuDd;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EACvD,QAAQ,EAAE,EAAE,EACZ,gBAAgB,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,EAAE,GAAG,SAAS,GAClD,OAAO,CAyBT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAChC,CAAC,GAAG,OAAO,EAEX,MAAM,EAAE,4BAA4B,CAAC,QAAQ,EAAE,OAAO,CAAC,EACvD,SAAS,EAAE,EAAE,EACb,cAAc,EAAE,cAAc,CAAC,OAAO,CAAC,EACvC,gBAAgB,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,EAAE,GAAG,SAAS,EACnD,IAAI,CAAC,EAAE,oBAAoB,CAAC,OAAO,EAAE,CAAC,CAAC,GACtC,gBAAgB,CA2DlB"}