@devisfuture/mega-collection 1.1.0 → 1.1.1

package/dist/filter/index.d.mts

@@ -18,18 +18,45 @@ declare class FilterEngine<T extends CollectionItem> {
     private previousResult;
     private previousCriteria;
     private previousBaseData;
+    /**
+     * Creates a new FilterEngine with optional data and fields to index.
+     */
     constructor(options?: FilterEngineOptions<T>);
+    /**
+     * Builds an index for the given field.
+     */
     private buildIndex;
     clearIndexes(): void;
     resetFilterState(): void;
+    /**
+     * Filters the data based on the given criteria.
+     */
     filter(criteria: FilterCriterion<T>[]): T[];
     filter(data: T[], criteria: FilterCriterion<T>[]): T[];
     private cloneCriteria;
+    /**
+     * Checks if there are new criteria added.
+     */
     private hasCriteriaAdditions;
+    /**
+     * Checks if there are criteria removed.
+     */
     private hasCriteriaRemovals;
+    /**
+     * Gets the newly added criteria.
+     */
     private getAddedCriteria;
+    /**
+     * Filters data linearly without index.
+     */
     private linearFilter;
+    /**
+     * Filters data using the index.
+     */
     private filterViaIndex;
+    /**
+     * Estimates the size of the index for a criterion.
+     */
     private estimateIndexSize;
 }
 

package/dist/merge/index.d.mts

@@ -21,11 +21,27 @@ interface MergeEnginesOptions<T extends CollectionItem> {
 }
 declare class MergeEngines<T extends CollectionItem> {
     private readonly engine;
+    /**
+     * Creates a new MergeEngines instance with the given options.
+     * Collects all modules from imports.
+     */
     constructor(options: MergeEnginesOptions<T>);
+    /**
+     * Gets the initialization options for a module.
+     */
     private getModuleInitOptions;
+    /**
+     * Gets the method names from a prototype.
+     */
     private getMethodNames;
+    /**
+     * Checks if an object has a specific method.
+     */
     private hasMethod;
     private isRecord;
+    /**
+     * Calls a method on the engine.
+     */
     private callEngineMethod;
     search(query: string): T[];
     search(field: keyof T & string, query: string): T[];

package/dist/search/index.d.mts

@@ -15,16 +15,40 @@ declare class TextSearchEngine<T extends CollectionItem> {
     private ngramIndexes;
     private data;
     private readonly minQueryLength;
+    /**
+     * Creates a new TextSearchEngine with optional data and fields to index.
+     */
     constructor(options?: TextSearchEngineOptions<T>);
+    /**
+     * Builds an n-gram index for the given field.
+     */
     private buildIndex;
     search(query: string): T[];
     search(field: keyof T & string, query: string): T[];
     private normalizeQuery;
+    /**
+     * Checks if the query is long enough to search.
+     */
     private isQuerySearchable;
+    /**
+     * Searches all indexed fields.
+     */
     private searchAllFields;
+    /**
+     * Searches a specific field.
+     */
     private searchField;
+    /**
+     * Searches a field using prepared query grams.
+     */
     private searchFieldWithPreparedQuery;
+    /**
+     * Searches all fields linearly without index.
+     */
     private searchAllFieldsLinear;
+    /**
+     * Searches a specific field linearly without index.
+     */
     private searchFieldLinear;
     clear(): void;
 }

package/dist/sort/index.d.mts

@@ -13,14 +13,38 @@ interface SortEngineOptions<T extends CollectionItem = CollectionItem> {
 declare class SortEngine<T extends CollectionItem> {
     private cache;
     private data;
+    /**
+     * Creates a new SortEngine with optional data and fields to index.
+     */
     constructor(options?: SortEngineOptions<T>);
+    /**
+     * Builds an index for sorting the given field.
+     */
     private buildIndex;
+    /**
+     * Clears all cached indexes.
+     */
     clearIndexes(): void;
+    /**
+     * Sorts the data based on the given descriptors.
+     */
     sort(descriptors: SortDescriptor<T>[]): T[];
     sort(data: T[], descriptors: SortDescriptor<T>[], inPlace?: boolean): T[];
+    /**
+     * Reconstructs the sorted array from the cached index.
+     */
     private reconstructFromIndex;
+    /**
+     * Checks if the field snapshot is still valid.
+     */
     private isFieldSnapshotValid;
+    /**
+     * Builds a comparator function for sorting.
+     */
     private buildComparator;
+    /**
+     * Sorts numeric data using radix sort.
+     */
     private radixSortNumeric;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devisfuture/mega-collection",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "High-performance search, filter & sort engine for 100K+ item collections in JavaScript/TypeScript",
   "exports": {
     ".": {