@hitgrab/finder 0.0.26-alpha → 0.1.3-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,12 @@
-import { EventCallback } from "../types/internal-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,108 +1,97 @@
-import { MatchesSnapshot, FinderConstructorOptions, FinderEventName } from "../types";
-import { PluginMediator } from "./plugins/plugin-mediator";
-import { EventCallback } from "./types/internal-types";
-declare class FinderCore<FItem> {
+import { FinderConstructorOptions, SnapshotSerializedMixins } from "./types/core-types";
+import { FinderRule } from "./types/rule-types";
+/**
+ * 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;
-    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>);
-    emitFirstUserInteraction(): void;
+    constructor(items: FItem[] | null | undefined, options: FinderConstructorOptions<FItem>);
     get items(): FItem[];
-    get matches(): MatchesSnapshot<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;
         searchTerm: string;
-        activeRule: import("..").SearchRule<unknown> | undefined;
         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) => 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;
-        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>;
+        values: Record<string, any>;
         raw: Record<string, any>;
-        activeRules: import("..").HydratedFilterRule<any, any>[];
-        rules: import("..").HydratedFilterRule<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>;
+        activeRules: import("..").HydratedFilterRule<unknown, any, any>[];
+        rules: import("..").HydratedFilterRule<unknown, any, any>[];
+        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(): {
+        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;
-        activeRule: import("..").SortByRule<unknown> | undefined;
-        sortDirection: import("..").SortDirection;
-        userHasSetSortDirection: boolean;
-        rules: import("..").SortByRule<unknown>[];
+        reset: () => void;
     };
     get groupBy(): {
-        set: (identifier?: import("..").GroupByRule | string) => 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;
+        set: (identifier?: string | import("..").GroupByRule) => void;
+        toggle: (identifier: import("..").GroupByRule | string) => void;
+        setGroupSortDirection: (direction?: import("..").SortDirection) => 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;
         page: number;
         offset: number;
         numItemsPerPage: number | undefined;
         numTotalItems: number;
         lastPage: number | undefined;
         isPaginated: boolean;
+        setPage: (value: number) => void;
+        setNumItemsPerPage: (value?: number) => void;
     };
-    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;
-    };
-    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>[]): 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.d.ts

@@ -0,0 +1,23 @@
+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, FContext> {
+    #private;
+    requireGroup: boolean;
+    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;
+    setGroupSortDirection(direction?: SortDirection): void;
+    toggle(identifier: GroupByRule | string): void;
+    reset(): void;
+    serialize(): SerializedGroupByMixin;
+    static process<FItem>(options: SerializedGroupByMixin, items: FItem[], context?: unknown): FinderResultGroup<FItem>[];
+}
+export { GroupByMixin };

package/dist/core/{pagination/pagination.d.ts → 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.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(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/calculate-string-match-segments.d.ts

@@ -0,0 +1,9 @@
+import { StringMatchSegment } from "../types/string-match-types";
+/**
+ * Helper function to determine which specfic characters are matched inside a string.
+ */
+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): boolean;

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/{haystack.d.ts → string-match-haystack.d.ts}

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

package/dist/core/search.d.ts

@@ -0,0 +1,18 @@
+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 hasSearchRule(): boolean;
+    get hasSearchTerm(): boolean;
+    setSearchTerm(incomingSearchTerm: string): void;
+    reset(): void;
+    serialize(): SerializedSearchMixin;
+    test(searchTerm: string, isAdditive?: boolean): FItem[];
+    static process<FItem>(options: SerializedSearchMixin, items: FItem[], context?: unknown): FItem[];
+}
+export { SearchMixin };

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

@@ -0,0 +1,23 @@
+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>(options: SerializedSortByMixin, items: FItem[], context: unknown): FItem[];
+}
+export { SortByMixin };

package/dist/core/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,93 @@
+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";
+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 MixinInjectedDependencies<FItem = any, FContext = any> {
+    isLoading: () => boolean;
+    isDisabled: () => boolean;
+    getRuleBook: () => RuleBook<FItem, FContext>;
+    touch: FinderTouchCallback;
+    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;
+}
+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

@@ -0,0 +1,20 @@
+import { FinderCore } from "../finder-core";
+import { FinderRule } from "./rule-types";
+export interface RuleEffect<FItem = any, 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;
+}
+export interface HydratedRuleEffect<FItem = any, FContext = any> {
+    rules: (string | FinderRule<FItem>)[];
+    onChange: (instance: FinderCore<FItem, FContext>) => void;
+    _isHydrated: true;
+}
+export interface SearchEffect<FItem = any, FContext = any> {
+    haystack: string | string[] | ((items: FItem[], context: FContext) => string | string[]);
+    onChange: (instance: FinderCore<FItem, FContext>) => void;
+}
+export interface HydratedSearchEffect<FItem = any, FContext = any> {
+    haystack: string[];
+    onChange: (instance: FinderCore<FItem, FContext>) => void;
+    _isHydrated: true;
+}

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

@@ -0,0 +1,44 @@
+import { EVENT_SOURCE, EVENTS } from "../core-constants";
+import { FinderCore } from "../finder-core";
+import { FinderRule } from "./rule-types";
+export type FinderTouchSource = (typeof EVENT_SOURCE)[keyof typeof EVENT_SOURCE];
+interface FinderSharedEventProps {
+    source: string;
+    event: FinderEventName;
+    timestamp: number;
+    instance: FinderCore;
+}
+export interface FinderInitEvent extends FinderSharedEventProps {
+    source: "core";
+    event: "init";
+}
+export interface FinderFirstUserInteractionEvent extends FinderSharedEventProps {
+    source: "core";
+    event: "firstUserInteraction";
+}
+export interface FinderReadyEvent extends FinderSharedEventProps {
+    source: "core";
+    event: "ready";
+}
+export type FinderEvent = FinderInitEvent | FinderFirstUserInteractionEvent | FinderReadyEvent | FinderChangeEvent;
+export type FinderOnInitCallback = (event: FinderInitEvent) => void;
+export type FinderOnReadyCallback = (event: FinderReadyEvent) => void;
+export type FinderOnFirstUserInteractCallback = (event: FinderFirstUserInteractionEvent) => void;
+export type FinderOnChangeCallback = (event: FinderChangeEvent) => void;
+export type FinderTouchCallback = (event: FinderTouchEvent) => void;
+/**
+ * Internal communication between mixins and core
+ */
+export interface FinderTouchEvent {
+    source: FinderTouchSource;
+    event: FinderEventName;
+    current: any;
+    initial: any;
+    rule?: FinderRule;
+}
+/**
+ * External type that consumers will receive
+ */
+export type FinderChangeEvent = FinderTouchEvent & FinderSharedEventProps;
+export type FinderEventName = (typeof EVENTS)[keyof typeof EVENTS];
+export {};