@hitgrab/finder 0.0.26-alpha → 0.1.0-alpha

package/dist/core/effect-book/effect-book.d.ts

@@ -0,0 +1,8 @@
+import { HydratedRuleEffect, HydratedSearchEffect, RuleEffect, SearchEffect } from "../types/effect-types";
+export declare class EffectBook<FItem, FContext> {
+    #private;
+    searchEffects: HydratedSearchEffect[];
+    ruleEffects: HydratedRuleEffect[];
+    constructor(effects: (RuleEffect | SearchEffect)[], items: FItem[], context: FContext);
+    hydrateDefinitions<FItem, FContext>(items: FItem[], context: FContext): void;
+}

package/dist/core/events/event-emitter.d.ts

@@ -1,4 +1,4 @@
-import { EventCallback } from "../types/internal-types";
+import { EventCallback } from "../types/core-types";
 /**
  * A barebones event emitter
  */
@@ -8,4 +8,5 @@ export declare class EventEmitter<EventNames extends string> {
     off(event: EventNames, callback: EventCallback): void;
     emit(event: EventNames, payload?: any): void;
     silently(callback: CallableFunction): void;
+    isSilent(): boolean;
 }

package/dist/core/filters/filters-interface.d.ts

@@ -3,30 +3,29 @@ import { FiltersMixin } from "./filters";
  * Public surface for the Filters mixin
  */
 declare function readonlyFiltersInterface(mixin: FiltersMixin): {
-    filters: Record<string, any>;
+    values: Record<string, any>;
     raw: Record<string, any>;
-    activeRules: import("../..").HydratedFilterRule<any, any>[];
-    rules: import("../..").HydratedFilterRule<any, any>[];
+    activeRules: import("../..").HydratedFilterRule<unknown, any, any>[];
+    rules: import("../..").HydratedFilterRule<unknown, any, any>[];
     isActive: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => boolean;
     get: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => any;
     has: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule, optionValue?: import("../..").FilterOption | any) => any;
-    getRule: <FItem = any, FValue = any>(identifier: string | import("../..").FilterRuleUnion<FItem, FValue> | import("../..").HydratedFilterRule<FItem, FValue>) => import("../..").HydratedFilterRule<FItem, FValue>;
+    getRule: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => import("../..").HydratedFilterRule<any, any, any> | undefined;
 };
 declare function filtersInterface(mixin: FiltersMixin): {
-    toggle: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => void;
-    toggleOption: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule, optionValue: import("../..").FilterOption | any) => void;
-    set: <FItem, FValue>(identifier: string | import("../..").FilterRuleUnion<FItem, FValue> | import("../..").HydratedFilterRule<FItem, FValue>, incomingFilterValue: FValue | FValue[]) => void;
+    toggle: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule, optionValue?: import("../..").FilterOption | any) => void;
+    set: <FItem, FValue>(identifier: string | import("../..").FilterRuleUnion<FItem, FValue> | import("../..").HydratedFilterRule<FItem, FValue, any>, incomingFilterValue: FValue | FValue[]) => void;
     delete: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => void;
-    test: (options: import("../../types").FilterTestOptions) => any[];
-    testRule: ({ rule: identifier, value, ...options }: import("../../types").FilterTestRuleOptions) => any[];
-    testRuleOptions: ({ rule: identifier, ...options }: import("../../types").FilterTestRuleOptionsOptions) => Map<any, any>;
-    filters: Record<string, any>;
+    test: (options: import("../types/rule-types").FilterTestOptions) => any[];
+    testRule: ({ rule: identifier, value, ...options }: import("../types/rule-types").FilterTestRuleOptions) => any[];
+    testRuleOptions: ({ rule: identifier, ...options }: import("../types/rule-types").FilterTestRuleOptionsOptions) => Map<any, any>;
+    values: Record<string, any>;
     raw: Record<string, any>;
-    activeRules: import("../..").HydratedFilterRule<any, any>[];
-    rules: import("../..").HydratedFilterRule<any, any>[];
+    activeRules: import("../..").HydratedFilterRule<unknown, any, any>[];
+    rules: import("../..").HydratedFilterRule<unknown, any, any>[];
     isActive: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => boolean;
     get: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => any;
     has: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule, optionValue?: import("../..").FilterOption | any) => any;
-    getRule: <FItem = any, FValue = any>(identifier: string | import("../..").FilterRuleUnion<FItem, FValue> | import("../..").HydratedFilterRule<FItem, FValue>) => import("../..").HydratedFilterRule<FItem, FValue>;
+    getRule: (identifier: string | import("../..").FilterRuleUnion | import("../..").HydratedFilterRule) => import("../..").HydratedFilterRule<any, any, any> | undefined;
 };
 export { readonlyFiltersInterface, filtersInterface };

package/dist/core/filters/filters.d.ts

@@ -1,29 +1,28 @@
-import { HydratedFilterRule, FilterOption, FilterTestOptions, FilterTestRuleOptions, FilterTestRuleOptionsOptions, MetaInterface, FilterRuleUnion } from "../../types";
-import { MixinInjectedDependencies } from "../types/internal-types";
-type InitialValues = {
+import { FilterOption, FilterRule, FilterRuleUnion, FilterTestOptions, FilterTestRuleOptions, FilterTestRuleOptionsOptions, HydratedFilterRule } from "../types/rule-types";
+import { MixinInjectedDependencies, SerializedFiltersMixin } from "../types/core-types";
+interface InitialValues {
     initialFilters: Record<string, any> | undefined;
-};
+}
 declare class FiltersMixin {
     #private;
-    filters: Record<string, any>;
     constructor({ initialFilters }: InitialValues, deps: MixinInjectedDependencies);
     set<FItem, FValue>(identifier: FilterRuleUnion<FItem, FValue> | HydratedFilterRule<FItem, FValue> | string, incomingFilterValue: FValue | FValue[]): void;
-    get rules(): HydratedFilterRule<any, any>[];
-    clearHydratedRules(): void;
-    getRule<FItem = any, FValue = any>(identifier: FilterRuleUnion<FItem, FValue> | HydratedFilterRule<FItem, FValue> | string): HydratedFilterRule<FItem, FValue>;
-    get activeRules(): HydratedFilterRule<any, any>[];
+    get rules(): HydratedFilterRule<unknown, any, any>[];
+    get activeRules(): HydratedFilterRule<unknown, any, any>[];
     get(identifier: string | FilterRuleUnion | HydratedFilterRule): any;
     has(identifier: string | FilterRuleUnion | HydratedFilterRule, optionValue?: FilterOption | any): any;
+    getRule(identifier: string | FilterRuleUnion | HydratedFilterRule): HydratedFilterRule<any, any, any> | undefined;
     delete(identifier: string | FilterRuleUnion | HydratedFilterRule): void;
-    isActive(identifier: string | FilterRuleUnion | HydratedFilterRule): boolean;
-    toggle(identifier: string | FilterRuleUnion | HydratedFilterRule): void;
-    toggleOption(identifier: string | FilterRuleUnion | HydratedFilterRule, optionValue: FilterOption | any): void;
+    isRuleActive(identifier: string | FilterRuleUnion | HydratedFilterRule): boolean;
+    toggle(identifier: string | FilterRuleUnion | HydratedFilterRule, optionValue?: FilterOption | any): void;
     test(options: FilterTestOptions): any[];
     testRule({ rule: identifier, value, ...options }: FilterTestRuleOptions): any[];
     testRuleOptions({ rule: identifier, ...options }: FilterTestRuleOptionsOptions): Map<any, any>;
-    getFilters(): Record<string, any>;
-    process(items: any[], meta: MetaInterface): any[];
-    static process<FItem>(items: FItem[], rules: HydratedFilterRule[], values: Record<string, any>, meta: MetaInterface): FItem[];
-    static isActive(rule: FilterRuleUnion | HydratedFilterRule, value: any): boolean;
+    getValues(): Record<string, any>;
+    getRawValues(): Record<string, any>;
+    serialize(): SerializedFiltersMixin;
+    static process<FItem>(options: SerializedFiltersMixin, items: FItem[], context?: any): FItem[];
+    static isRuleActive(rule: FilterRuleUnion | HydratedFilterRule, value: any): boolean;
+    static hydrateRule<FItem = any, FContext = any>(rule: FilterRule, items: FItem[], context: FContext): HydratedFilterRule;
 }
 export { FiltersMixin };

package/dist/core/finder-core.d.ts

@@ -1,41 +1,42 @@
-import { MatchesSnapshot, FinderConstructorOptions, FinderEventName } from "../types";
-import { PluginMediator } from "./plugins/plugin-mediator";
-import { EventCallback } from "./types/internal-types";
-declare class FinderCore<FItem> {
+import { FinderEventName } from "./types/event-types";
+import { FinderRule } from "./types/rule-types";
+import { EventCallback, FinderConstructorOptions, SnapshotSerializedMixins } from "./types/core-types";
+declare class FinderCore<FItem, FContext = any> {
     #private;
     isReady: boolean;
     isLoading: boolean;
     disabled: boolean;
     updatedAt?: number;
-    plugins: PluginMediator<FItem>;
-    constructor(items: FItem[] | null | undefined, { rules, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialFilters, initialSelectedItems, initialMeta, page, numItemsPerPage, isLoading, disabled, requireGroup, maxSelectedItems, layoutVariants, initialLayout, plugins, onInit, onReady, onFirstUserInteraction, onChange, }: FinderConstructorOptions<FItem>);
+    context: FContext;
+    constructor(items: FItem[] | null | undefined, { rules, effects, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialFilters, context, page, numItemsPerPage, isLoading, disabled, requireGroup, ignoreSortByRulesWhileSearchRuleIsActive, onInit, onReady, onFirstUserInteraction, onChange, }: FinderConstructorOptions<FItem, FContext>);
     emitFirstUserInteraction(): void;
     get items(): FItem[];
-    get matches(): MatchesSnapshot<FItem>;
+    get matches(): import("./types/core-types").ResultSnapshot<FItem>;
+    test(mixins: SnapshotSerializedMixins, isAdditive?: boolean): FItem[];
     get isEmpty(): boolean;
     get search(): {
         setSearchTerm: (incomingSearchTerm: string) => void;
         reset: () => void;
+        test: (searchTerm: string, isAdditive?: boolean) => FItem[];
         searchTerm: string;
-        activeRule: import("..").SearchRule<unknown> | undefined;
         hasSearchTerm: boolean;
+        hasSearchRule: boolean;
     };
     get filters(): {
-        toggle: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule) => void;
-        toggleOption: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule, optionValue: import("..").FilterOption | any) => void;
-        set: <FItem_1, FValue>(identifier: string | import("..").FilterRuleUnion<FItem_1, FValue> | import("..").HydratedFilterRule<FItem_1, FValue>, incomingFilterValue: FValue | FValue[]) => void;
+        toggle: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule, optionValue?: import("..").FilterOption | any) => void;
+        set: <FItem_1, FValue>(identifier: string | import("..").FilterRuleUnion<FItem_1, FValue> | import("..").HydratedFilterRule<FItem_1, FValue, any>, incomingFilterValue: FValue | FValue[]) => void;
         delete: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule) => void;
-        test: (options: import("../types").FilterTestOptions) => any[];
-        testRule: ({ rule: identifier, value, ...options }: import("../types").FilterTestRuleOptions) => any[];
-        testRuleOptions: ({ rule: identifier, ...options }: import("../types").FilterTestRuleOptionsOptions) => Map<any, any>;
-        filters: Record<string, any>;
+        test: (options: import("./types/rule-types").FilterTestOptions) => any[];
+        testRule: ({ rule: identifier, value, ...options }: import("./types/rule-types").FilterTestRuleOptions) => any[];
+        testRuleOptions: ({ rule: identifier, ...options }: import("./types/rule-types").FilterTestRuleOptionsOptions) => Map<any, any>;
+        values: Record<string, any>;
         raw: Record<string, any>;
-        activeRules: import("..").HydratedFilterRule<any, any>[];
-        rules: import("..").HydratedFilterRule<any, any>[];
+        activeRules: import("..").HydratedFilterRule<unknown, any, any>[];
+        rules: import("..").HydratedFilterRule<unknown, any, any>[];
         isActive: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule) => boolean;
         get: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule) => any;
         has: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule, optionValue?: import("..").FilterOption | any) => any;
-        getRule: <FItem_1 = any, FValue = any>(identifier: string | import("..").FilterRuleUnion<FItem_1, FValue> | import("..").HydratedFilterRule<FItem_1, FValue>) => import("..").HydratedFilterRule<FItem_1, FValue>;
+        getRule: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule) => import("..").HydratedFilterRule<any, any, any> | undefined;
     };
     get sortBy(): {
         set: (identifier?: string | import("..").SortByRule, incomingSortDirection?: import("..").SortDirection) => void;
@@ -43,29 +44,21 @@ declare class FinderCore<FItem> {
         cycleSortDirection: () => void;
         toggleSortDirection: () => void;
         reset(): void;
-        activeRule: import("..").SortByRule<unknown> | undefined;
+        activeRule: import("..").SortByRule<unknown, any> | undefined;
         sortDirection: import("..").SortDirection;
         userHasSetSortDirection: boolean;
-        rules: import("..").SortByRule<unknown>[];
+        rules: import("..").SortByRule<unknown, any>[];
     };
     get groupBy(): {
-        set: (identifier?: import("..").GroupByRule | string) => void;
+        set: (identifier?: string | import("..").GroupByRule) => void;
         toggle: (identifier: import("..").GroupByRule | string) => void;
         setGroupIdSortDirection: (direction?: import("..").SortDirection) => void;
         reset: () => void;
-        activeRule: import("..").GroupByRule<unknown> | undefined;
+        activeRule: import("..").GroupByRule<unknown, any> | undefined;
         requireGroup: boolean;
-        rules: import("..").GroupByRule<unknown>[];
+        rules: import("..").GroupByRule<unknown, any>[];
         groupIdSortDirection: import("..").SortDirection | undefined;
     };
-    get meta(): {
-        set: (metaIdentifier: any, value: any) => void;
-        delete: (metaIdentifier: any) => void;
-        reset: () => void;
-        value: Record<string, any>;
-        get: (metaIdentifier: any) => any;
-        has: (metaIdentifier: any) => boolean;
-    };
     get pagination(): {
         setPage: (value: number) => void;
         setNumItemsPerPage: (value?: number) => void;
@@ -76,33 +69,18 @@ declare class FinderCore<FItem> {
         lastPage: number | undefined;
         isPaginated: boolean;
     };
-    get selectedItems(): {
-        setMaxSelectedItems: (value?: number) => void;
-        select: (item: FItem) => void;
-        selectOnly: (item: FItem) => void;
-        delete: (item: FItem) => void;
-        toggle: (item: FItem) => void;
-        toggleOnly: (item: FItem) => void;
-        reset: () => void;
-        items: FItem[];
-        maxSelectedItems: number | undefined;
-        isSelected: (item: FItem) => boolean;
-    };
-    get layout(): {
-        set: (identifier: string | import("..").LayoutVariant | undefined) => void;
-        reset: () => void;
-        variants: import("..").LayoutVariant[];
-        activeLayout: import("..").LayoutVariant | undefined;
-        raw: import("..").LayoutVariant | undefined;
-        is: (identifier: string | import("..").LayoutVariant | undefined) => boolean;
-    };
     get events(): {
         on: (event: FinderEventName, callback: EventCallback) => void;
         off: (event: FinderEventName, callback: EventCallback) => void;
+        silently: (callback: EventCallback) => void;
+        isSilent: () => boolean;
     };
+    getRule<Rule>(identifier: string | FinderRule<FItem>): Rule;
     get state(): "loading" | "empty" | "groups" | "items" | "noMatches";
     setItems(items: FItem[] | null | undefined): void;
     setIsLoading(value?: boolean): void;
     setIsDisabled(value?: boolean): void;
+    setRules(definitions: FinderRule<FItem, FContext>[]): void;
+    setContext(context: FContext): void;
 }
 export { FinderCore };

package/dist/core/group-by/group-by-interface.d.ts

@@ -2,20 +2,20 @@ import { GroupByMixin } from "./group-by";
 /**
  * Public surface for the Group By mixin
  */
-declare function readonlyGroupByInterface<FItem>(mixin: GroupByMixin<FItem>): {
-    activeRule: import("../..").GroupByRule<unknown> | undefined;
+declare function readonlyGroupByInterface<FItem, FContext>(mixin: GroupByMixin<FItem, FContext>): {
+    activeRule: import("../..").GroupByRule<unknown, any> | undefined;
     requireGroup: boolean;
-    rules: import("../..").GroupByRule<unknown>[];
+    rules: import("../..").GroupByRule<unknown, any>[];
     groupIdSortDirection: import("../..").SortDirection | undefined;
 };
-declare function groupByInterface<FItem>(mixin: GroupByMixin<FItem>): {
-    set: (identifier?: import("../..").GroupByRule | string) => void;
+declare function groupByInterface<FItem, FContext>(mixin: GroupByMixin<FItem, FContext>): {
+    set: (identifier?: string | import("../..").GroupByRule) => void;
     toggle: (identifier: import("../..").GroupByRule | string) => void;
     setGroupIdSortDirection: (direction?: import("../..").SortDirection) => void;
     reset: () => void;
-    activeRule: import("../..").GroupByRule<unknown> | undefined;
+    activeRule: import("../..").GroupByRule<unknown, any> | undefined;
     requireGroup: boolean;
-    rules: import("../..").GroupByRule<unknown>[];
+    rules: import("../..").GroupByRule<unknown, any>[];
     groupIdSortDirection: import("../..").SortDirection | undefined;
 };
 export { readonlyGroupByInterface, groupByInterface };

package/dist/core/group-by/group-by.d.ts

@@ -1,20 +1,22 @@
-import { GroupByRule, FinderResultGroup, SortDirection, MetaInterface } from "../../types";
-import { MixinInjectedDependencies } from "../types/internal-types";
-type InitialValues = {
+import { GroupByRule } from "../types/rule-types";
+import { FinderResultGroup, MixinInjectedDependencies, SerializedGroupByMixin, SortDirection } from "../types/core-types";
+interface InitialValues {
     initialGroupBy: string | undefined;
     requireGroup: boolean;
-};
-declare class GroupByMixin<FItem> {
+}
+declare class GroupByMixin<FItem, FContext> {
     #private;
     requireGroup: boolean;
     groupIdSortDirection?: SortDirection;
-    constructor({ initialGroupBy, requireGroup }: InitialValues, deps: MixinInjectedDependencies<FItem>);
-    get rules(): GroupByRule<unknown>[];
-    get activeRule(): GroupByRule<unknown> | undefined;
-    set(identifier?: GroupByRule | string): void;
+    constructor({ initialGroupBy, requireGroup }: InitialValues, deps: MixinInjectedDependencies<FItem, FContext>);
+    get rules(): GroupByRule<unknown, any>[];
+    get activeRule(): GroupByRule<unknown, any> | undefined;
+    get hasGroupByRule(): boolean;
+    set(identifier?: string | GroupByRule): void;
     setGroupIdSortDirection(direction?: SortDirection): void;
     toggle(identifier: GroupByRule | string): void;
     reset(): void;
-    process(items: FItem[], meta: MetaInterface): FinderResultGroup<FItem>[];
+    serialize(): SerializedGroupByMixin;
+    static process<FItem, FContext>(options: SerializedGroupByMixin, items: FItem[], context?: FContext): FinderResultGroup<FItem>[];
 }
 export { GroupByMixin };

package/dist/core/pagination/pagination.d.ts

@@ -1,8 +1,8 @@
-import { MixinInjectedDependencies } from "../types/internal-types";
-type InitialValues = {
+import { MixinInjectedDependencies, SerializedPaginationMixin } from "../types/core-types";
+interface InitialValues {
     page: number | undefined;
     numItemsPerPage: number | undefined;
-};
+}
 declare class PaginationMixin<FItem> {
     #private;
     numItemsPerPage?: number;
@@ -13,6 +13,7 @@ declare class PaginationMixin<FItem> {
     get numTotalItems(): number;
     get page(): number;
     get offset(): number;
-    process(items: FItem[]): FItem[];
+    serialize(): SerializedPaginationMixin;
+    static process<FItem>(options: SerializedPaginationMixin, items: FItem[]): FItem[];
 }
 export { PaginationMixin };

package/dist/core/rule-book/rule-book.d.ts

@@ -0,0 +1,14 @@
+import { FinderRule } from "../types/rule-types";
+/**
+ * Stores rule definitions and hydrated rules
+ */
+export declare class RuleBook<FItem, FContext> {
+    #private;
+    rules: FinderRule<FItem>[];
+    constructor(definitions: FinderRule<FItem>[], items: FItem[], context: FContext);
+    hydrateDefinitions<FItem, FContext>(items: FItem[], context: FContext): void;
+    getRule<Rule>(identifier: string | FinderRule): Rule | undefined;
+    getDefinitions(): FinderRule<FItem>[];
+    setRules(definitions: FinderRule<FItem>[]): void;
+    static validateDefinitions(definitions: FinderRule[]): boolean;
+}

package/dist/core/search/algorithms/sequential-characters.d.ts

@@ -1,2 +1 @@
-import { Haystack } from "../haystack";
-export declare function calculateSequentialCharacterIndexes(haystack: Haystack, needle: string): number[] | undefined;
+export declare function calculateSequentialCharacterIndexes(haystack: string, needle: string): number[] | undefined;

package/dist/core/search/algorithms/sequential-string.d.ts

@@ -1,2 +1 @@
-import { Haystack } from "../haystack";
-export declare function calculateSequentialStringCharacterIndexes(haystack: Haystack, needle: string): number[] | undefined;
+export declare function calculateSequentialStringCharacterIndexes(haystack: string, needle: string): number[] | undefined;

package/dist/core/search/{haystack.d.ts → result-segments/result-segment-haystack.d.ts}

@@ -1,4 +1,4 @@
-export declare class Haystack {
+export declare class ResultSegmentHaystack {
     #private;
     source: string;
     transformed: string;

package/dist/core/search/result-segments/result-segment-types.d.ts

@@ -1,4 +1,3 @@
-import { Haystack } from "../haystack";
 /**
  * Internal type used to prepare the result segment. These values all point to the transformed haystack.
  */
@@ -11,8 +10,8 @@ export interface ResultSegmentInternal {
     _internal: true;
 }
 /**
- * Consumabel type ready for use. All values are mapped to the haystack source.
+ * Consumable type ready for use. All values are mapped to the haystack source.
  */
 export interface ResultSegment extends Omit<ResultSegmentInternal, "_internal"> {
 }
-export type SearchCharacterIndexFn = (haystack: Haystack, needle: string) => number[] | undefined;
+export type SearchCharacterIndexFn = (haystack: string, needle: string) => number[] | undefined;

package/dist/core/search/result-segments/search-result-segments.d.ts

@@ -1,17 +1,9 @@
-import { ResultSegment, SearchCharacterIndexFn } from "./result-segment-types";
+import { ResultSegment } from "./result-segment-types";
 /**
  * Helper function to determine which specfic characters are matched inside a string.
  */
-export declare function getSearchResultSegments(characterIndexFn: SearchCharacterIndexFn, haystack: string, needle: string, aliases?: string[] | null): ResultSegment[] | undefined;
+export declare function getSearchResultSegments(haystack: string | string[], needle: string): ResultSegment[] | undefined;
 /**
  * Determine if a characterIndexFn would return a result for a haystack.
  */
-export declare function hasCharacterIndexMatches(characterIndexFn: SearchCharacterIndexFn, haystack: string, needle: string, aliases?: string[] | null): boolean;
-/**
- * Ensure haystacks and needles are formatted consistently.
- *
- * Transforming includes:
- * 1. Convert to lowercase.
- * 2. Strip all non-word and non-digit characters.
- */
-export declare function transformStringForComparison(value: string): string;
+export declare function hasCharacterIndexMatches(haystack: string | string[], needle: string, exact?: boolean): boolean;

package/dist/core/search/search-interface.d.ts

@@ -1,14 +1,15 @@
 import { SearchMixin } from "./search";
 declare function readonlySearchInterface<FItem>(mixin: SearchMixin<FItem>): {
     searchTerm: string;
-    activeRule: import("../..").SearchRule<unknown> | undefined;
     hasSearchTerm: boolean;
+    hasSearchRule: boolean;
 };
 declare function searchInterface<FItem>(mixin: SearchMixin<FItem>): {
     setSearchTerm: (incomingSearchTerm: string) => void;
     reset: () => void;
+    test: (searchTerm: string, isAdditive?: boolean) => FItem[];
     searchTerm: string;
-    activeRule: import("../..").SearchRule<unknown> | undefined;
     hasSearchTerm: boolean;
+    hasSearchRule: boolean;
 };
 export { readonlySearchInterface, searchInterface };

package/dist/core/search/search-score.d.ts

@@ -0,0 +1,4 @@
+export declare function calculateSearchScore(indexes: number[], haystack: string): {
+    percentOfHaystackMatched: number;
+    longestSequentialSequence: number;
+};

package/dist/core/search/search-string-transform.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensure haystacks and needles are formatted consistently.
+ *
+ * Transforming includes:
+ * 1. Convert to lowercase.
+ * 2. Strip all non-word and non-digit characters.
+ */
+export declare function transformStringForComparison(value: string): string;

package/dist/core/search/search.d.ts

@@ -1,16 +1,18 @@
-import { MetaInterface } from "../../types";
-import { MixinInjectedDependencies } from "../types/internal-types";
+import { MixinInjectedDependencies, SerializedSearchMixin } from "../types/core-types";
 type InitialValues = {
     initialSearchTerm: string | undefined;
 };
 declare class SearchMixin<FItem> {
     #private;
+    searchTerm: string;
     constructor({ initialSearchTerm }: InitialValues, deps: MixinInjectedDependencies<FItem>);
-    get searchTerm(): string;
-    get rule(): import("../..").SearchRule<unknown> | undefined;
+    get rule(): import("../..").SearchRule<unknown, any> | undefined;
     get hasSearchRule(): boolean;
+    get hasSearchTerm(): boolean;
     setSearchTerm(incomingSearchTerm: string): void;
     reset(): void;
-    process(items: FItem[], meta: MetaInterface): FItem[];
+    serialize(): SerializedSearchMixin;
+    test(searchTerm: string, isAdditive?: boolean): FItem[];
+    static process<FItem, FContext>(options: SerializedSearchMixin, items: FItem[], context?: FContext): FItem[];
 }
 export { SearchMixin };

package/dist/core/sort-by/sort-by-interface.d.ts

@@ -1,13 +1,13 @@
-import { SortDirection } from "../../types";
+import { SortDirection } from "../types/core-types";
 import { SortByMixin } from "./sort-by";
 /**
  * Public surface for the SortBy mixin
  */
 declare function readonlySortByInterface<FItem>(mixin: SortByMixin<FItem>): {
-    activeRule: import("../..").SortByRule<unknown> | undefined;
+    activeRule: import("../..").SortByRule<unknown, any> | undefined;
     sortDirection: SortDirection;
     userHasSetSortDirection: boolean;
-    rules: import("../..").SortByRule<unknown>[];
+    rules: import("../..").SortByRule<unknown, any>[];
 };
 declare function sortByInterface<FItem>(mixin: SortByMixin<FItem>): {
     set: (identifier?: string | import("../..").SortByRule, incomingSortDirection?: SortDirection) => void;
@@ -15,9 +15,9 @@ declare function sortByInterface<FItem>(mixin: SortByMixin<FItem>): {
     cycleSortDirection: () => void;
     toggleSortDirection: () => void;
     reset(): void;
-    activeRule: import("../..").SortByRule<unknown> | undefined;
+    activeRule: import("../..").SortByRule<unknown, any> | undefined;
     sortDirection: SortDirection;
     userHasSetSortDirection: boolean;
-    rules: import("../..").SortByRule<unknown>[];
+    rules: import("../..").SortByRule<unknown, any>[];
 };
 export { readonlySortByInterface, sortByInterface };

package/dist/core/sort-by/sort-by.d.ts

@@ -1,5 +1,5 @@
-import { SortByRule, SortDirection } from "../../types";
-import { MixinInjectedDependencies } from "../types/internal-types";
+import { SortByRule } from "../types/rule-types";
+import { MixinInjectedDependencies, SerializedSortByMixin, SortDirection } from "../types/core-types";
 type InitialValues = {
     initialSortBy: string | undefined;
     initialSortDirection?: SortDirection;
@@ -7,12 +7,13 @@ type InitialValues = {
 declare class SortByMixin<FItem> {
     #private;
     constructor({ initialSortBy, initialSortDirection }: InitialValues, deps: MixinInjectedDependencies<FItem>);
-    get rules(): SortByRule<unknown>[];
-    get activeRule(): SortByRule<unknown> | undefined;
+    get rules(): SortByRule<unknown, any>[];
+    get activeRule(): SortByRule<unknown, any> | undefined;
     get sortDirection(): SortDirection;
     get userHasSetSortDirection(): boolean;
     setSortDirection(incomingSortDirection?: SortDirection): void;
     set(identifier?: string | SortByRule, incomingSortDirection?: SortDirection): void;
-    process(items: FItem[]): FItem[];
+    serialize(): SerializedSortByMixin;
+    static process<FItem, FContext>(options: SerializedSortByMixin, items: FItem[], context: FContext): FItem[];
 }
 export { SortByMixin };

package/dist/core/tester/tester.d.ts

@@ -0,0 +1,8 @@
+import { ResultSnapshot, SnapshotOptions } from "../types/core-types";
+export declare class Tester<FItem, FContext> {
+    snapshot: ResultSnapshot<FItem>;
+    isStale: boolean;
+    setIsStale(value: boolean): void;
+    takeSnapshot({ items, context, mixins }: SnapshotOptions<FItem, FContext>): void;
+    static test<FItem, FContext>({ mixins, items, context }: SnapshotOptions<FItem, FContext>): FItem[];
+}

package/dist/core/types/core-types.d.ts

@@ -0,0 +1,92 @@
+import { DebounceCallbackRegistry } from "../debounce-callback-registry/debounce-callback-registry";
+import { readonlyFiltersInterface } from "../filters/filters-interface";
+import { readonlyGroupByInterface } from "../group-by/group-by-interface";
+import { RuleBook } from "../rule-book/rule-book";
+import { readonlySearchInterface } from "../search/search-interface";
+import { readonlySortByInterface } from "../sort-by/sort-by-interface";
+import { RuleEffect, SearchEffect } from "./effect-types";
+import { FinderOnChangeCallback, FinderOnFirstUserInteractCallback, FinderOnInitCallback, FinderOnReadyCallback, FinderTouchCallback } from "./event-types";
+import { FinderRule, GroupByRule, HydratedFilterRule, SearchRule, SortByRule } from "./rule-types";
+export interface FinderConstructorOptions<FItem, FContext = any> {
+    rules: FinderRule<FItem>[];
+    effects?: (RuleEffect | SearchEffect)[];
+    context?: FContext;
+    isLoading?: boolean;
+    disabled?: boolean;
+    initialSearchTerm?: string;
+    initialSortBy?: string;
+    initialSortDirection?: SortDirection;
+    initialGroupBy?: string;
+    initialFilters?: Record<string, any>;
+    ignoreSortByRulesWhileSearchRuleIsActive?: boolean;
+    requireGroup?: boolean;
+    page?: number;
+    numItemsPerPage?: number;
+    onInit?: FinderOnInitCallback;
+    onReady?: FinderOnReadyCallback;
+    onFirstUserInteraction?: FinderOnFirstUserInteractCallback;
+    onChange?: FinderOnChangeCallback;
+}
+export interface FinderResultGroup<FItem> {
+    id: string;
+    items: FItem[];
+}
+export type SortDirection = "asc" | "desc" | ("asc" | "desc")[];
+export interface ResultSnapshot<FItem> {
+    items?: FItem[];
+    groups?: FinderResultGroup<FItem>[];
+    numMatchedItems: number;
+    numTotalItems: number;
+    hasGroupByRule: boolean;
+}
+export interface FinderSnapshot<FItem, FContext = any> {
+    search: ReturnType<typeof readonlySearchInterface<FItem>>;
+    filters: ReturnType<typeof readonlyFiltersInterface>;
+    sortBy: ReturnType<typeof readonlySortByInterface<FItem>>;
+    groupBy: ReturnType<typeof readonlyGroupByInterface<FItem, FContext>>;
+    context?: FContext;
+    updatedAt?: number;
+}
+export interface MixinInjectedDependencies<FItem = any, FContext = any> {
+    isLoading: () => boolean;
+    isDisabled: () => boolean;
+    getRuleBook: () => RuleBook<FItem, FContext>;
+    touch: FinderTouchCallback;
+    getContext: () => any;
+    getItems: () => FItem[];
+    test: (serializedMixins: SnapshotSerializedMixins, isAdditive?: boolean) => FItem[];
+    debouncer: DebounceCallbackRegistry;
+}
+export type EventCallback = (payload?: any) => void;
+export interface SnapshotOptions<FItem, FContext> {
+    items: FItem[];
+    context: FContext;
+    mixins: SnapshotSerializedMixins;
+}
+export interface SnapshotSerializedMixins {
+    search?: SerializedSearchMixin;
+    filters?: SerializedFiltersMixin;
+    sortBy?: SerializedSortByMixin;
+    pagination?: SerializedPaginationMixin;
+    groupBy?: SerializedGroupByMixin;
+}
+export interface SerializedSearchMixin {
+    searchTerm: string;
+    rule?: SearchRule;
+}
+export interface SerializedFiltersMixin {
+    rules: HydratedFilterRule[];
+    values: Record<string, any>;
+}
+export interface SerializedSortByMixin {
+    rule?: SortByRule;
+    sortDirection?: SortDirection;
+}
+export interface SerializedPaginationMixin {
+    page: number;
+    numItemsPerPage?: number;
+}
+export interface SerializedGroupByMixin {
+    rule?: GroupByRule;
+    sortDirection?: SortDirection;
+}