@hitgrab/finder 0.1.0-alpha → 0.1.4-alpha

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

@@ -1,6 +1,6 @@
-export type MockObjectItem = {
+export interface MockObjectItem {
     type: string;
     name: string;
     price: number;
     daysUntilExpiryDate: string;
-};
+}

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

@@ -0,0 +1,39 @@
+export declare const EVENTS: {
+    readonly INIT: "init";
+    readonly FIRST_USER_INTERACTION: "firstUserInteraction";
+    readonly READY: "ready";
+    readonly CHANGE: "change";
+    readonly SET_ITEMS: "setItems";
+    readonly SET_IS_LOADING: "setIsLoading";
+    readonly SET_IS_DISABLED: "setIsDisabled";
+    readonly SET_CONTEXT: "setContext";
+    readonly SET_SEARCH_TERM: "setSearchTerm";
+    readonly RESET_SEARCH_TERM: "resetSearchTerm";
+    readonly SET_FILTER: "setFilter";
+    readonly SET_SORT_BY: "setSortBy";
+    readonly SET_SORT_BY_DIRECTION: "setSortDirection";
+    readonly SET_GROUP_BY: "setGroupBy";
+    readonly SET_GROUP_SORT_BY_DIRECTION: "setGroupBySortDirection";
+    readonly SET_PAGE: "setPage";
+    readonly SET_NUM_ITEMS_PER_PAGE: "setNumItemsPerPage";
+};
+export declare const EVENT_SOURCE: {
+    readonly CORE: "core";
+    readonly SEARCH: "search";
+    readonly FILTERS: "filters";
+    readonly GROUP_BY: "groupBy";
+    readonly SORT_BY: "sortBy";
+    readonly PAGINATION: "pagination";
+};
+export declare const ERRORS: {
+    RULE_NOT_FOUND: string;
+    WRONG_RULE_TYPE_FOR_MIXIN: string;
+    NO_SEARCH_RULE_SET: string;
+    TOGGLING_OPTION_ON_RULE_WITH_NO_OPTIONS: string;
+    TOGGLING_OPTION_ON_RULE_WITH_SINGLE_VALUE: string;
+    TOGGLING_OPTION_THAT_DOES_NOT_EXIST: string;
+    TESTING_OPTIONS_ON_RULE_WITH_NO_OPTIONS: string;
+    INVALID_RULE_WITHOUT_ID: string;
+    INVALID_RULE_SHAPE: string;
+    INVALID_RULE_DUPLICATE: string;
+};

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

@@ -0,0 +1,12 @@
+import { FinderCore } from "./finder-core";
+import { HydratedRuleEffect, HydratedSearchEffect, RuleEffect, SearchEffect } from "./types/effect-types";
+import { FinderRule } from "./types/rule-types";
+export declare class EffectBook<FItem, FContext> {
+    #private;
+    searchEffects: HydratedSearchEffect[];
+    ruleEffects: HydratedRuleEffect[];
+    constructor(effects: (RuleEffect | SearchEffect)[], items: FItem[], context: FContext);
+    hydrateDefinitions(items: FItem[], context: FContext): void;
+    processRule(rule: FinderRule, instance: FinderCore): void;
+    processSearchTerm(searchTerm: string, instance: FinderCore): void;
+}

package/dist/core/{events/event-emitter.d.ts → event-emitter.d.ts}

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

package/dist/core/filters.d.ts

@@ -0,0 +1,28 @@
+import { FilterRuleUnion, FilterTestOptions, FilterTestRuleOptions, FilterTestRuleOptionsOptions, HydratedFilterRule } from "./types/rule-types";
+import { MixinInjectedDependencies, SerializedFiltersMixin } from "./types/core-types";
+interface InitialValues {
+    initialFilters: Record<string, any> | undefined;
+}
+type FilterRuleIdentifier = string | FilterRuleUnion | HydratedFilterRule;
+declare class FiltersMixin {
+    #private;
+    constructor({ initialFilters }: InitialValues, deps: MixinInjectedDependencies);
+    set<FValue>(identifier: FilterRuleIdentifier, incomingFilterValue: FValue | FValue[]): void;
+    get rules(): HydratedFilterRule<unknown, any, any>[];
+    get activeRules(): HydratedFilterRule<unknown, any, any>[];
+    get(identifier: FilterRuleIdentifier): any;
+    has(identifier: FilterRuleIdentifier, optionValue?: any): boolean;
+    getRule(identifier: FilterRuleIdentifier): HydratedFilterRule<any, any, any>;
+    delete(identifier: FilterRuleIdentifier): void;
+    isRuleActive(identifier: FilterRuleIdentifier): boolean;
+    toggle(identifier: FilterRuleIdentifier, optionValue?: any): void;
+    test(options: FilterTestOptions): any[];
+    testRule({ rule: identifier, value, ...options }: FilterTestRuleOptions): any[];
+    testRuleOptions({ rule: identifier, ...options }: FilterTestRuleOptionsOptions): Map<any, any>;
+    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;
+}
+export { FiltersMixin };

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

@@ -0,0 +1,44 @@
+import { SearchMixin } from "./search";
+import { FiltersMixin } from "./filters";
+import { SortByMixin } from "./sort-by";
+import { GroupByMixin } from "./group-by";
+import { PaginationMixin } from "./pagination";
+import { FinderCore } from "./finder-core";
+import { FinderConstructorOptions, SnapshotSerializedMixins, EventCallback } from "./types/core-types";
+import { FinderEventName } from "./types/event-types";
+import { FinderRule } from "./types/rule-types";
+declare class FinderCoreImplementation<FItem, FContext> {
+    #private;
+    isReady: boolean;
+    isLoading: boolean;
+    disabled: boolean;
+    updatedAt: number;
+    search: SearchMixin<FItem>;
+    filters: FiltersMixin;
+    sortBy: SortByMixin<FItem>;
+    groupBy: GroupByMixin<FItem, FContext>;
+    pagination: PaginationMixin<FItem>;
+    context: FContext;
+    getInstanceFn: () => FinderCore;
+    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>, getInstanceFn: () => FinderCore);
+    emitFirstUserInteraction(): void;
+    get items(): FItem[];
+    get matches(): import("./types/core-types").ResultSnapshot<FItem>;
+    test(mixins: SnapshotSerializedMixins, isAdditive?: boolean): FItem[];
+    get isEmpty(): boolean;
+    get hasMatches(): boolean;
+    get events(): {
+        on: (event: FinderEventName, callback: EventCallback) => void;
+        off: (event: FinderEventName, callback: EventCallback) => void;
+        silently: (callback: EventCallback) => void;
+        isSilent: () => boolean;
+    };
+    getRule(identifier: string | FinderRule<FItem>): FinderRule<FItem>;
+    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 { FinderCoreImplementation };

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

@@ -1,86 +1,97 @@
-import { FinderEventName } from "./types/event-types";
+import { FinderConstructorOptions, SnapshotSerializedMixins } from "./types/core-types";
 import { FinderRule } from "./types/rule-types";
-import { EventCallback, FinderConstructorOptions, SnapshotSerializedMixins } from "./types/core-types";
-declare class FinderCore<FItem, FContext = any> {
+/**
+ * This thin wrapper around FinderCoreImplementation defines the mixin interfaces and hides private methods.
+ */
+declare class FinderCore<FItem = any, FContext = any> {
     #private;
-    isReady: boolean;
-    isLoading: boolean;
-    disabled: boolean;
-    updatedAt?: number;
-    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;
+    constructor(items: FItem[] | null | undefined, options: FinderConstructorOptions<FItem>);
     get items(): FItem[];
-    get matches(): import("./types/core-types").ResultSnapshot<FItem>;
-    test(mixins: SnapshotSerializedMixins, isAdditive?: boolean): FItem[];
+    get context(): FContext;
+    get isReady(): boolean;
     get isEmpty(): boolean;
+    get hasMatches(): boolean;
+    get isLoading(): boolean;
+    get disabled(): boolean;
+    get state(): "loading" | "empty" | "groups" | "items" | "noMatches";
+    get updatedAt(): number;
+    get events(): {
+        on: (event: import("./types/event-types").FinderEventName, callback: import("./types/core-types").EventCallback) => void;
+        off: (event: import("./types/event-types").FinderEventName, callback: import("./types/core-types").EventCallback) => void;
+        silently: (callback: import("./types/core-types").EventCallback) => void;
+        isSilent: () => boolean;
+    };
+    /**
+     * Mixin interfaces
+     */
+    get matches(): import("./types/core-types").ResultSnapshot<FItem>;
     get search(): {
-        setSearchTerm: (incomingSearchTerm: string) => void;
-        reset: () => void;
-        test: (searchTerm: string, isAdditive?: boolean) => FItem[];
         searchTerm: string;
         hasSearchTerm: boolean;
         hasSearchRule: boolean;
+        setSearchTerm: (incomingSearchTerm: string) => void;
+        reset: () => void;
+        test: (searchTerm: string, isAdditive?: boolean) => FItem[];
     };
     get filters(): {
-        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/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<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: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule) => import("..").HydratedFilterRule<any, any, any> | undefined;
+        isActive: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>) => boolean;
+        get: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>) => any;
+        has: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>, optionValue?: any) => boolean;
+        getRule: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>) => import("..").HydratedFilterRule<any, any, any>;
+        toggle: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>, optionValue?: any) => void;
+        set: <FValue>(identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>, incomingFilterValue: FValue | FValue[]) => void;
+        delete: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>) => void;
+        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>;
     };
     get sortBy(): {
-        set: (identifier?: string | import("..").SortByRule, incomingSortDirection?: import("..").SortDirection) => void;
-        setSortDirection: (incomingSortDirection?: import("..").SortDirection) => void;
-        cycleSortDirection: () => void;
-        toggleSortDirection: () => void;
-        reset(): void;
         activeRule: import("..").SortByRule<unknown, any> | undefined;
         sortDirection: import("..").SortDirection;
         userHasSetSortDirection: boolean;
         rules: import("..").SortByRule<unknown, any>[];
+        set: (identifier?: string | import("..").SortByRule, incomingSortDirection?: import("..").SortDirection) => void;
+        setSortDirection: (incomingSortDirection?: import("..").SortDirection) => void;
+        cycleSortDirection: () => void;
+        toggleSortDirection: () => void;
+        reset: () => void;
     };
     get groupBy(): {
-        set: (identifier?: string | import("..").GroupByRule) => void;
-        toggle: (identifier: import("..").GroupByRule | string) => void;
-        setGroupIdSortDirection: (direction?: import("..").SortDirection) => void;
-        reset: () => void;
         activeRule: import("..").GroupByRule<unknown, any> | undefined;
         requireGroup: boolean;
         rules: import("..").GroupByRule<unknown, any>[];
         groupIdSortDirection: import("..").SortDirection | undefined;
+        set: (identifier?: string | import("..").GroupByRule) => void;
+        toggle: (identifier: import("..").GroupByRule | string) => void;
+        setGroupSortDirection: (direction?: import("..").SortDirection) => void;
+        reset: () => void;
     };
     get pagination(): {
-        setPage: (value: number) => void;
-        setNumItemsPerPage: (value?: number) => void;
         page: number;
         offset: number;
         numItemsPerPage: number | undefined;
         numTotalItems: number;
         lastPage: number | undefined;
         isPaginated: boolean;
+        setPage: (value: number) => void;
+        setNumItemsPerPage: (value?: number) => void;
     };
-    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";
+    /**
+     * Mutators
+     */
     setItems(items: FItem[] | null | undefined): void;
     setIsLoading(value?: boolean): void;
     setIsDisabled(value?: boolean): void;
-    setRules(definitions: FinderRule<FItem, FContext>[]): void;
+    setRules(definitions: FinderRule<FItem>[]): void;
     setContext(context: FContext): void;
+    /**
+     * Utils
+     */
+    test(mixins: SnapshotSerializedMixins, isAdditive?: boolean): FItem[];
+    getRule(identifier: string | FinderRule<FItem>): FinderRule<FItem>;
 }
 export { FinderCore };

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

@@ -0,0 +1,3 @@
+export declare class FinderError extends Error {
+    constructor(message: string, options?: any);
+}

package/dist/core/{group-by/group-by.d.ts → group-by.d.ts}

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

package/dist/core/{pagination/pagination.d.ts → pagination.d.ts}

@@ -1,4 +1,4 @@
-import { MixinInjectedDependencies, SerializedPaginationMixin } from "../types/core-types";
+import { MixinInjectedDependencies, SerializedPaginationMixin } from "./types/core-types";
 interface InitialValues {
     page: number | undefined;
     numItemsPerPage: number | undefined;

package/dist/core/{rule-book/rule-book.d.ts → rule-book.d.ts}

@@ -1,4 +1,4 @@
-import { FinderRule } from "../types/rule-types";
+import { FinderRule } from "./types/rule-types";
 /**
  * Stores rule definitions and hydrated rules
  */
@@ -6,8 +6,8 @@ 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;
+    hydrateDefinitions(items: FItem[], context: FContext): void;
+    getRule(identifier: string | FinderRule): FinderRule<FItem>;
     getDefinitions(): FinderRule<FItem>[];
     setRules(definitions: FinderRule<FItem>[]): void;
     static validateDefinitions(definitions: FinderRule[]): boolean;

package/dist/core/search/calculate-character-match-indexes.d.ts

@@ -0,0 +1 @@
+export declare function calculateCharacterMatchIndexes(haystack: string, needle: string): number[] | undefined;

package/dist/core/search/{result-segments/search-result-segments.d.ts → calculate-string-match-segments.d.ts}

@@ -1,9 +1,9 @@
-import { ResultSegment } from "./result-segment-types";
+import { StringMatchSegment } from "../types/string-match-types";
 /**
  * Helper function to determine which specfic characters are matched inside a string.
  */
-export declare function getSearchResultSegments(haystack: string | string[], needle: string): ResultSegment[] | undefined;
+export declare function calculateStringMatchSegments(haystack: string | string[], needle: string): StringMatchSegment[] | undefined;
 /**
  * Determine if a characterIndexFn would return a result for a haystack.
  */
-export declare function hasCharacterIndexMatches(haystack: string | string[], needle: string, exact?: boolean): boolean;
+export declare function hasCharacterIndexMatches(haystack: string | string[], needle: string): boolean;

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

@@ -1,4 +1,4 @@
-export declare class ResultSegmentHaystack {
+export declare class StringMatchHaystack {
     #private;
     source: string;
     transformed: string;
@@ -9,7 +9,7 @@ export declare class ResultSegmentHaystack {
      */
     static composeTransformedHaystackSegments(haystack: string): {
         value: string;
-        start: number;
-        end: number;
+        index: number;
+        length: number;
     }[];
 }

package/dist/core/{search/search.d.ts → search.d.ts}

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

package/dist/core/{sort-by/sort-by.d.ts → sort-by.d.ts}

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

package/dist/core/{tester/tester.d.ts → tester.d.ts}

@@ -1,4 +1,4 @@
-import { ResultSnapshot, SnapshotOptions } from "../types/core-types";
+import { ResultSnapshot, SnapshotOptions } from "./types/core-types";
 export declare class Tester<FItem, FContext> {
     snapshot: ResultSnapshot<FItem>;
     isStale: boolean;

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

@@ -1,9 +1,5 @@
-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 { DebounceCallbackRegistry } from "../debounce-callback-registry";
+import { RuleBook } from "../rule-book";
 import { RuleEffect, SearchEffect } from "./effect-types";
 import { FinderOnChangeCallback, FinderOnFirstUserInteractCallback, FinderOnInitCallback, FinderOnReadyCallback, FinderTouchCallback } from "./event-types";
 import { FinderRule, GroupByRule, HydratedFilterRule, SearchRule, SortByRule } from "./rule-types";
@@ -39,20 +35,11 @@ export interface ResultSnapshot<FItem> {
     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;
@@ -90,3 +77,17 @@ export interface SerializedGroupByMixin {
     rule?: GroupByRule;
     sortDirection?: SortDirection;
 }
+export interface SearchScore {
+    percentOfHaystackMatched: number;
+    longestSequentialSequence: number;
+}
+export interface PaginationMixinInterface {
+    page: number;
+    offset: number;
+    numItemsPerPage: number | undefined;
+    numTotalItems: number;
+    lastPage: number | undefined;
+    isPaginated: boolean;
+    setPage: (value: number) => void;
+    setNumItemsPerPage: (value: number) => void;
+}

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

@@ -12,11 +12,9 @@ export interface HydratedRuleEffect<FItem = any, FContext = any> {
 export interface SearchEffect<FItem = any, FContext = any> {
     haystack: string | string[] | ((items: FItem[], context: FContext) => string | string[]);
     onChange: (instance: FinderCore<FItem, FContext>) => void;
-    exact?: boolean;
 }
 export interface HydratedSearchEffect<FItem = any, FContext = any> {
     haystack: string[];
     onChange: (instance: FinderCore<FItem, FContext>) => void;
-    exact: boolean;
     _isHydrated: true;
 }

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

@@ -1,11 +1,12 @@
-import { FinderSnapshot } from "./core-types";
+import { EVENT_SOURCE, EVENTS } from "../core-constants";
+import { FinderCore } from "../finder-core";
 import { FinderRule } from "./rule-types";
-export type FinderTouchSource = "core" | "filters" | "groupBy" | "pagination" | "search" | "sortBy";
+export type FinderTouchSource = (typeof EVENT_SOURCE)[keyof typeof EVENT_SOURCE];
 interface FinderSharedEventProps {
     source: string;
     event: FinderEventName;
-    snapshot: FinderSnapshot<any>;
     timestamp: number;
+    instance: FinderCore;
 }
 export interface FinderInitEvent extends FinderSharedEventProps {
     source: "core";
@@ -39,5 +40,5 @@ export interface FinderTouchEvent {
  * External type that consumers will receive
  */
 export type FinderChangeEvent = FinderTouchEvent & FinderSharedEventProps;
-export type FinderEventName = "init" | "firstUserInteraction" | "ready" | "change" | "change.core" | "change.core.setIsLoading" | "change.core.setIsDisabled" | "change.core.setItems" | "change.core.syncContext" | `change.filters` | "change.filters.set" | `change.groupBy` | "change.groupBy.set" | "change.groupBy.setGroupIdSortDirection" | "change.pagination" | "change.pagination.setPage" | "change.pagination.setNumItemsPerPage" | "change.search" | "change.search.setSearchTerm" | "change.search.reset" | "change.sortBy" | "change.sortBy.set" | "change.sortBy.setSortDirection";
+export type FinderEventName = (typeof EVENTS)[keyof typeof EVENTS];
 export {};

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

@@ -4,6 +4,7 @@ import { FinderResultGroup, SortDirection } from "./core-types";
  */
 export type FinderPropertySelector<FItem, FContext = any> = (item: FItem, context?: FContext) => string | number;
 export type FinderRule<FItem = any, FContext = any> = SearchRule<FItem, FContext> | FilterRuleUnion<FItem, FContext> | HydratedFilterRule<FItem, FContext> | SortByRule<FItem, FContext> | GroupByRule<FItem, FContext>;
+export type HydratedFinderRule<FItem = any, FContext = any> = SearchRule<FItem, FContext> | HydratedFilterRule<FItem, FContext> | SortByRule<FItem, FContext> | GroupByRule<FItem, FContext>;
 export interface SearchRule<FItem = any, FContext = any> {
     id?: string;
     label?: string;
@@ -30,30 +31,26 @@ export interface FilterRule<FItem = any, FValue = any, FContext = any> {
     label?: string;
     hidden?: boolean;
     debounceMilliseconds?: number;
-    multiple?: boolean;
-    boolean?: boolean;
-    filterFn: CallableFunction;
-    defaultValue?: any;
 }
-interface FilterRuleWithBooleanValue<FItem, FValue = boolean, FContext = any> extends FilterRule<FItem, FValue> {
+export interface FilterRuleWithBooleanValue<FItem, FContext = any> extends FilterRule<FItem> {
     multiple?: false;
     boolean: true;
-    filterFn: (item: FItem, value: FValue, context?: FContext) => boolean;
+    filterFn: (item: FItem, value: boolean, context?: FContext) => boolean;
     defaultValue?: boolean;
 }
-interface FilterRuleWithScalarValue<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
+export interface FilterRuleWithSingleValue<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
     multiple?: false;
     boolean?: false;
     filterFn: (item: FItem, value: FValue, context?: FContext) => boolean;
     defaultValue?: FValue;
 }
-interface FilterRuleWithMultipleValues<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
+export interface FilterRuleWithMultipleValues<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
     multiple: true;
     boolean?: false;
     filterFn: (item: FItem, value: FValue[], context?: FContext) => boolean;
     defaultValue?: FValue[];
 }
-export type FilterRuleUnion<FItem = any, FValue = any> = FilterRuleWithBooleanValue<FItem> | FilterRuleWithScalarValue<FItem, FValue> | FilterRuleWithMultipleValues<FItem, FValue>;
+export type FilterRuleUnion<FItem = any, FValue = any> = FilterRuleWithBooleanValue<FItem> | FilterRuleWithSingleValue<FItem, FValue> | FilterRuleWithMultipleValues<FItem, FValue>;
 /**
  * A hydrated filter has rendered any option generator functions, and narrowed ambiguous properties from FilterRule.
  */
@@ -77,8 +74,8 @@ export interface SortByRule<FItem = any, FContext = any> {
 export interface GroupByRule<FItem = any, FContext = any> {
     id: string;
     groupFn: FinderPropertySelector<FItem, FContext>;
-    sortGroupIdFn?: FinderPropertySelector<FinderResultGroup<FItem>, FContext>;
-    groupIdSortDirection?: SortDirection;
+    sortGroupFn?: FinderPropertySelector<FinderResultGroup<FItem>, FContext>;
+    defaultGroupSortDirection?: SortDirection;
     sticky?: {
         header?: string | string[];
         footer?: string | string[];
@@ -105,4 +102,3 @@ export interface FilterTestRuleOptionsOptions {
     isAdditive?: boolean;
     mergeExistingValue?: boolean;
 }
-export {};

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

@@ -0,0 +1,10 @@
+/**
+ *  These values all point to the transformed haystack.
+ */
+export interface StringMatchSegment {
+    index: number;
+    length: number;
+    is_match: boolean;
+    value: string;
+}
+export type SearchCharacterIndexFn = (haystack: string, needle: string) => number[] | undefined;

package/dist/core/utils/rule-type-enforcers.d.ts

@@ -1,13 +1,15 @@
 import { FinderCore } from "../finder-core";
 import { RuleEffect, SearchEffect } from "../types/effect-types";
-import { FilterRuleUnion, FinderRule, GroupByRule, SearchRule, SortByRule } from "../types/rule-types";
+import { FilterRuleWithBooleanValue, FilterRuleWithMultipleValues, FilterRuleWithSingleValue, FinderRule, GroupByRule, SearchRule, SortByRule } from "../types/rule-types";
 /**
  * Enforce structure for an array of rule of mixed types.
  */
 export declare function finderRuleset<FItem>(rules: FinderRule<FItem>[]): FinderRule<FItem>[];
 export declare function searchRule<FItem>(rule: SearchRule<FItem>): SearchRule<FItem, any>;
-export declare function filterRule<FItem, FValue = any>(rule: FilterRuleUnion<FItem, FValue>): FilterRuleUnion<FItem, FValue>;
+export declare function filterRule<FItem, FValue = any, T = FilterRuleWithMultipleValues<FItem, FValue>>(rule: T): FilterRuleWithMultipleValues<FItem, FValue>;
+export declare function filterRule<FItem, FValue = any, T = FilterRuleWithBooleanValue<FItem, FValue>>(rule: T): FilterRuleWithBooleanValue<FItem, FValue>;
+export declare function filterRule<FItem, FValue = any, T = FilterRuleWithSingleValue<FItem, FValue>>(rule: T): FilterRuleWithSingleValue<FItem, FValue>;
 export declare function sortByRule<FItem>(rule: SortByRule<FItem>): SortByRule<FItem, any>;
 export declare function groupByRule<FItem>(rule: GroupByRule<FItem>): GroupByRule<FItem, any>;
 export declare function ruleEffect<FItem, FContext = any>(rules: string | FinderRule<FItem> | (string | FinderRule<FItem>)[] | ((items: FItem[], context: FContext) => string | FinderRule<FItem> | (string | FinderRule<FItem>)[]), onChange: (instance: FinderCore<FItem, FContext>) => void): RuleEffect<FItem, FContext>;
-export declare function searchEffect<FItem, FContext = any>(haystack: string | string[] | ((items: FItem[], context: FContext) => string | string[]), onChange: (instance: FinderCore<FItem, FContext>) => void, exact?: boolean): SearchEffect<FItem, FContext>;
+export declare function searchEffect<FItem, FContext = any>(haystack: string | string[] | ((items: FItem[], context: FContext) => string | string[]), onChange: (instance: FinderCore<FItem, FContext>) => void): SearchEffect<FItem, FContext>;