@hitgrab/finder 0.1.16-alpha → 0.1.18-alpha

package/dist/core/__tests__/json.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -10,6 +10,7 @@ export declare const EVENTS: {
     readonly SET_SEARCH_TERM: "setSearchTerm";
     readonly RESET_SEARCH_TERM: "resetSearchTerm";
     readonly SET_FILTER: "setFilter";
+    readonly RESET_FILTERS: "resetFilters";
     readonly SET_SORT_BY: "setSortBy";
     readonly SET_SORT_BY_DIRECTION: "setSortDirection";
     readonly SET_GROUP_BY: "setGroupBy";
@@ -30,6 +31,8 @@ export declare const ERRORS: {
     RULE_NOT_FOUND: string;
     WRONG_RULE_TYPE_FOR_MIXIN: string;
     NO_SEARCH_RULE_SET: string;
+    INVALID_SEARCH_TERM_TYPE: string;
+    NO_MATCHING_OPTION_FOUND_WITH_STRICT_OPTIONS: string;
     SETTING_MULTIPLE_FILTER_WITHOUT_ARRAY: string;
     ADDING_OPTION_TO_MULTIPLE_FILTER_WITHOUT_OPTION_VALUE: string;
     DELETING_OPTION_VALUE_FROM_NON_MULTIPLE_FILTER: string;
@@ -39,6 +42,7 @@ export declare const ERRORS: {
     TOGGLING_OPTION_ON_RULE_WITH_SINGLE_VALUE: string;
     TOGGLING_OPTION_THAT_DOES_NOT_EXIST: string;
     TOGGLING_OPTION_WITHOUT_PASSING_OPTION: string;
+    TOGGLING_BOOLEAN_FILTER_WITH_UNUSED_VALUE: string;
     TESTING_OPTIONS_ON_RULE_WITH_NO_OPTIONS: string;
     INVALID_RULE_WITHOUT_ID: string;
     INVALID_RULE_SHAPE: string;

package/dist/core/debounce-callback-registry.d.ts

@@ -1,3 +1,3 @@
-import { FinderRule } from "./types/rule-types";
-declare function DebounceCallbackRegistry(): (rule: FinderRule, callback: () => void) => any;
+import { RuleDefinition } from "./types/rule-types";
+declare function DebounceCallbackRegistry(): (rule: RuleDefinition, callback: () => void) => any;
 export { DebounceCallbackRegistry };

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

@@ -1,12 +1,12 @@
 import { FinderCore } from "./finder-core";
 import { HydratedRuleEffect, HydratedSearchEffect, RuleEffect, SearchEffect } from "./types/effect-types";
-import { FinderRule } from "./types/rule-types";
+import { RuleDefinition } 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;
+    processRule(rule: RuleDefinition, instance: FinderCore): void;
     processSearchTerm(searchTerm: string, instance: FinderCore): void;
 }

package/dist/core/filters.d.ts

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

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

@@ -6,7 +6,7 @@ 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";
+import { RuleDefinition } from "./types/rule-types";
 declare class FinderCoreImplementation<FItem, FContext = any> {
     #private;
     isReady: boolean;
@@ -20,7 +20,7 @@ declare class FinderCoreImplementation<FItem, FContext = any> {
     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);
+    constructor(items: FItem[] | null | undefined, { rules, effects, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialGroupBySortDirection, 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>;
@@ -33,12 +33,13 @@ declare class FinderCoreImplementation<FItem, FContext = any> {
         silently: (callback: EventCallback) => void;
         isSilent: () => boolean;
     };
-    getRule(identifier: string | FinderRule<FItem>): FinderRule<FItem>;
+    getRule(identifier: string | RuleDefinition<FItem>): RuleDefinition;
     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;
+    setRules(definitions: RuleDefinition<FItem, FContext>[]): void;
     setContext(context: FContext): void;
+    toJSON(): Omit<FinderConstructorOptions<FItem>, "rules">;
 }
 export { FinderCoreImplementation };

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

@@ -1,5 +1,5 @@
 import { FinderConstructorOptions, SnapshotSerializedMixins } from "./types/core-types";
-import { FinderRule } from "./types/rule-types";
+import { RuleDefinition } from "./types/rule-types";
 /**
  * This thin wrapper around FinderCoreImplementation defines the mixin interfaces and hides private methods.
  */
@@ -26,7 +26,7 @@ declare class FinderCore<FItem = any, FContext = any> {
      */
     get matches(): import("./types/core-types").ResultSnapshot<FItem>;
     get search(): {
-        rule: import("..").SearchRule<unknown, any> | undefined;
+        rule: import("..").SearchRuleDefinition<unknown, any> | undefined;
         searchTerm: string;
         hasSearchTerm: boolean;
         hasSearchRule: boolean;
@@ -37,38 +37,39 @@ declare class FinderCore<FItem = any, FContext = any> {
     get filters(): {
         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<any, any, any>) => boolean;
-        get: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>) => any;
-        add: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>, optionValue: any) => void;
-        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>, value: FValue | FValue[]) => void;
-        delete: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>, optionValue?: any) => void;
+        activeRules: import("./types/rule-types").HydratedFilterRuleDefinition<any, any, any>[];
+        rules: import("./types/rule-types").HydratedFilterRuleDefinition<any, any, any>[];
+        isActive: (identifier: string | import("..").AnyFilterRuleDefinition<any, any>) => boolean;
+        get: (identifier: string | import("..").AnyFilterRuleDefinition<any, any>) => any;
+        add: <FValue>(identifier: string | import("..").AnyFilterRuleDefinition<any, FValue>, optionValue?: FValue | import("..").FilterOption<FValue>) => void;
+        has: (identifier: string | import("..").AnyFilterRuleDefinition<any, any>, optionValue?: any) => boolean;
+        getRule: (identifier: string | import("..").AnyFilterRuleDefinition<any, any>) => import("./types/rule-types").HydratedFilterRuleDefinition<any, any, any>;
+        toggle: <FValue>(identifier: string | import("..").AnyFilterRuleDefinition<any, FValue>, optionValue?: FValue | import("..").FilterOption<FValue>) => void;
+        set: <FValue>(identifier: string | import("..").AnyFilterRuleDefinition<any, FValue>, value?: FValue | FValue[]) => void;
+        delete: <FValue>(identifier: string | import("..").AnyFilterRuleDefinition<any, FValue>, optionValue?: FValue | import("..").FilterOption<FValue>) => void;
+        reset: () => void;
         test: (options: import("./types/rule-types").FilterTestOptions) => any[];
         testRule: ({ rule: identifier, value, ...options }: import("./types/rule-types").FilterTestRuleOptions) => any[];
-        testRuleOptions: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, any>, isAdditive?: boolean) => Map<any, any>;
+        testRuleOptions: (identifier: string | import("..").AnyFilterRuleDefinition<any, any>, isAdditive?: boolean) => Map<any, any>;
     };
     get sortBy(): {
-        activeRule: import("..").SortByRule<unknown, any> | undefined;
+        activeRule: import("..").SortByRuleDefinition<unknown, any> | undefined;
         sortDirection: import("..").SortDirection;
         userHasSetSortDirection: boolean;
-        rules: import("..").SortByRule<unknown, any>[];
-        set: (identifier?: string | import("..").SortByRule, incomingSortDirection?: import("..").SortDirection) => void;
+        rules: import("..").SortByRuleDefinition<unknown, any>[];
+        set: (identifier?: string | import("..").SortByRuleDefinition, incomingSortDirection?: import("..").SortDirection) => void;
         setSortDirection: (incomingSortDirection?: import("..").SortDirection) => void;
         cycleSortDirection: () => void;
         toggleSortDirection: () => void;
         reset: () => void;
     };
     get groupBy(): {
-        activeRule: import("..").GroupByRule<unknown, any> | undefined;
+        activeRule: import("..").GroupByRuleDefinition<unknown, any> | undefined;
         requireGroup: boolean;
-        rules: import("..").GroupByRule<unknown, any>[];
-        groupSortDirection: import("..").SortDirection | undefined;
-        set: (identifier?: string | import("..").GroupByRule) => void;
-        toggle: (identifier: import("..").GroupByRule | string) => void;
+        rules: import("..").GroupByRuleDefinition<unknown, any>[];
+        groupBySortDirection: import("..").SortDirection | undefined;
+        set: (identifier?: string | import("..").GroupByRuleDefinition<any, any>) => void;
+        toggle: (identifier: string | import("..").GroupByRuleDefinition<any, any>) => void;
         setGroupSortDirection: (direction?: import("..").SortDirection) => void;
         reset: () => void;
     };
@@ -88,12 +89,13 @@ declare class FinderCore<FItem = any, FContext = any> {
     setItems(items: FItem[] | null | undefined): void;
     setIsLoading(value?: boolean): void;
     setIsDisabled(value?: boolean): void;
-    setRules(definitions: FinderRule<FItem>[]): void;
+    setRules(definitions: RuleDefinition<FItem>[]): void;
     setContext(context: FContext): void;
     /**
      * Utils
      */
     test(mixins: SnapshotSerializedMixins, isAdditive?: boolean): FItem[];
-    getRule(identifier: string | FinderRule<FItem>): FinderRule<FItem>;
+    getRule<T extends RuleDefinition<FItem>>(identifier: string | RuleDefinition<FItem>): T | undefined;
+    toJSON(): Omit<FinderConstructorOptions<FItem, any>, "rules">;
 }
 export { FinderCore };

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

@@ -1,21 +1,23 @@
-import { GroupByRule } from "./types/rule-types";
+import { GroupByRuleDefinition } from "./types/rule-types";
 import { FinderResultGroup, MixinInjectedDependencies, SerializedGroupByMixin, SortDirection } from "./types/core-types";
 interface InitialValues {
     initialGroupBy: string | undefined;
+    initialGroupBySortDirection?: SortDirection;
     requireGroup: boolean;
 }
+type GroupByRuleIdentifier = string | GroupByRuleDefinition;
 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;
+    constructor({ initialGroupBy, initialGroupBySortDirection, requireGroup }: InitialValues, deps: MixinInjectedDependencies<FItem, FContext>);
+    getRule(identifier: GroupByRuleIdentifier): GroupByRuleDefinition<any, any>;
+    get rules(): GroupByRuleDefinition<unknown, any>[];
+    get activeRule(): GroupByRuleDefinition<unknown, any> | undefined;
     get hasGroupByRule(): boolean;
-    get groupSortDirection(): SortDirection | undefined;
-    set(identifier?: string | GroupByRule): void;
+    get groupBySortDirection(): SortDirection | undefined;
+    set(identifier?: GroupByRuleIdentifier): void;
     setGroupSortDirection(direction?: SortDirection): void;
-    toggle(identifier: GroupByRule | string): void;
+    toggle(identifier: GroupByRuleIdentifier): void;
     reset(): void;
     serialize(): SerializedGroupByMixin;
     static process<FItem>(options: SerializedGroupByMixin, items: FItem[], context: unknown): FinderResultGroup<FItem>[];

package/dist/core/rule-book/boolean-filter-handler.d.ts

@@ -0,0 +1,11 @@
+import { FilterRuleWithBooleanValue, HydratedFilterRuleDefinition } from "../types/rule-types";
+export declare function BooleanFilterHandler(definition: HydratedFilterRuleDefinition & FilterRuleWithBooleanValue): {
+    validate(value: unknown): boolean;
+    parse(value: unknown): boolean;
+    has(value: unknown): boolean;
+    toggle(value: unknown, optionValue?: any): boolean;
+    add(value: unknown, optionValue: any): never;
+    delete(value: unknown, optionValue?: any): undefined;
+    isActive(value: unknown): boolean;
+    isMatch(item: unknown, value: unknown, context: unknown): boolean;
+};

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

@@ -0,0 +1,29 @@
+import { HydratedFilterRuleDefinition } from "../types/rule-types";
+export declare function makeFilterHandler(definition: HydratedFilterRuleDefinition): {
+    validate(value: unknown): boolean;
+    parse(value: unknown): boolean;
+    has(value: unknown): boolean;
+    toggle(value: unknown, optionValue?: any): boolean;
+    add(value: unknown, optionValue: any): never;
+    delete(value: unknown, optionValue?: any): undefined;
+    isActive(value: unknown): boolean;
+    isMatch(item: unknown, value: unknown, context: unknown): boolean;
+} | {
+    validate(value: unknown): boolean;
+    parse(value: unknown): any[];
+    has(value: unknown, optionValue?: any): boolean;
+    toggle(value: unknown, optionValue?: any): any[];
+    add(value: unknown, optionValue: any): any[];
+    delete(value: unknown, optionValue?: any): any[] | undefined;
+    isActive(value: unknown): boolean;
+    isMatch(item: any, value: unknown, context: unknown): boolean;
+} | {
+    validate(value: unknown): boolean;
+    parse(value: unknown): any;
+    has(value: unknown): value is {} | null;
+    toggle(value: unknown, optionValue?: any): never;
+    add(value: unknown, optionValue: any): never;
+    delete(value: unknown, optionValue?: any): undefined;
+    isActive(value: unknown): boolean;
+    isMatch(item: unknown, value: unknown, context: unknown): boolean;
+};

package/dist/core/{filter-utils/multiple-filter.d.ts → rule-book/multiple-filter-handler.d.ts}

@@ -1,5 +1,5 @@
-import { HydratedFilterRule } from "../types/rule-types";
-export declare function MultipleFilter(rule: HydratedFilterRule): {
+import { FilterRuleWithMultipleValues, HydratedFilterRuleDefinition } from "../types/rule-types";
+export declare function MultipleFilterHandler(definition: HydratedFilterRuleDefinition & FilterRuleWithMultipleValues): {
     validate(value: unknown): boolean;
     parse(value: unknown): any[];
     has(value: unknown, optionValue?: any): boolean;
@@ -7,4 +7,5 @@ export declare function MultipleFilter(rule: HydratedFilterRule): {
     add(value: unknown, optionValue: any): any[];
     delete(value: unknown, optionValue?: any): any[] | undefined;
     isActive(value: unknown): boolean;
+    isMatch(item: any, value: unknown, context: unknown): boolean;
 };

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

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

package/dist/core/rule-book/single-filter-handler.d.ts

@@ -0,0 +1,11 @@
+import { FilterRuleWithSingleValue, HydratedFilterRuleDefinition } from "../types/rule-types";
+export declare function SingleFilterHandler(definition: HydratedFilterRuleDefinition & FilterRuleWithSingleValue): {
+    validate(value: unknown): boolean;
+    parse(value: unknown): any;
+    has(value: unknown): value is {} | null;
+    toggle(value: unknown, optionValue?: any): never;
+    add(value: unknown, optionValue: any): never;
+    delete(value: unknown, optionValue?: any): undefined;
+    isActive(value: unknown): boolean;
+    isMatch(item: unknown, value: unknown, context: unknown): boolean;
+};

package/dist/core/search/default-search-and-sort-algorithm.d.ts

@@ -0,0 +1,2 @@
+import { SerializedSearchMixin } from "../types/core-types";
+export declare function defaultSearchAndSortAlgorithm<FItem>(options: SerializedSearchMixin, items: FItem[], context: unknown): FItem[];

package/dist/core/search.d.ts

@@ -6,7 +6,7 @@ declare class SearchMixin<FItem> {
     #private;
     searchTerm: string;
     constructor({ initialSearchTerm }: InitialValues, deps: MixinInjectedDependencies<FItem>);
-    get rule(): import("..").SearchRule<unknown, any> | undefined;
+    get rule(): import("..").SearchRuleDefinition<unknown, any> | undefined;
     get hasSearchRule(): boolean;
     get hasSearchTerm(): boolean;
     setSearchTerm(value: string): void;

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

@@ -1,4 +1,4 @@
-import { SortByRule } from "./types/rule-types";
+import { SortByRuleDefinition } from "./types/rule-types";
 import { MixinInjectedDependencies, SerializedSortByMixin, SortDirection } from "./types/core-types";
 interface InitialValues {
     initialSortBy: string | undefined;
@@ -7,15 +7,15 @@ interface InitialValues {
 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;
+    getRule(identifier: string | SortByRuleDefinition): SortByRuleDefinition<any, any>;
+    get rules(): SortByRuleDefinition<unknown, any>[];
+    get activeRule(): SortByRuleDefinition<unknown, any> | undefined;
     get sortDirection(): SortDirection;
     get userHasSetSortDirection(): boolean;
     setSortDirection(incomingSortDirection?: SortDirection): void;
     cycleSortDirection(): void;
     toggleSortDirection(): void;
-    set(identifier?: string | SortByRule, incomingSortDirection?: SortDirection): void;
+    set(identifier?: string | SortByRuleDefinition, incomingSortDirection?: SortDirection): void;
     reset(): void;
     serialize(): SerializedSortByMixin;
     static process<FItem>(options: SerializedSortByMixin, items: FItem[], context: unknown): FItem[];

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

@@ -1,11 +1,10 @@
 import { DebounceCallbackRegistry } from "../debounce-callback-registry";
-import { FinderCore } from "../finder-core";
-import { RuleBook } from "../rule-book";
+import { RuleBook } from "../rule-book/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";
+import { RuleDefinition, GroupByRuleDefinition, SearchRuleDefinition, SortByRuleDefinition, HydratedFilterRuleDefinition } from "./rule-types";
 export interface FinderConstructorOptions<FItem, FContext = any> {
-    rules: FinderRule<FItem>[];
+    rules: RuleDefinition<FItem>[];
     effects?: (RuleEffect | SearchEffect)[];
     context?: FContext;
     isLoading?: boolean;
@@ -14,6 +13,7 @@ export interface FinderConstructorOptions<FItem, FContext = any> {
     initialSortBy?: string;
     initialSortDirection?: SortDirection;
     initialGroupBy?: string;
+    initialGroupBySortDirection?: SortDirection;
     initialFilters?: Record<string, any>;
     ignoreSortByRulesWhileSearchRuleIsActive?: boolean;
     requireGroup?: boolean;
@@ -60,14 +60,14 @@ export interface SnapshotSerializedMixins {
 }
 export interface SerializedSearchMixin {
     searchTerm: string;
-    rule?: SearchRule;
+    rule?: SearchRuleDefinition;
 }
 export interface SerializedFiltersMixin {
-    rules: HydratedFilterRule[];
+    rules: HydratedFilterRuleDefinition[];
     values: Record<string, any>;
 }
 export interface SerializedSortByMixin {
-    rule?: SortByRule;
+    rule?: SortByRuleDefinition;
     sortDirection?: SortDirection;
 }
 export interface SerializedPaginationMixin {
@@ -75,12 +75,8 @@ export interface SerializedPaginationMixin {
     numItemsPerPage?: number;
 }
 export interface SerializedGroupByMixin {
-    rule?: GroupByRule;
-    sortDirection?: SortDirection;
-}
-export interface SearchScore {
-    percentOfHaystackMatched: number;
-    longestSequentialSequence: number;
+    rule?: GroupByRuleDefinition;
+    groupBySortDirection?: SortDirection;
 }
 export interface PaginationMixinInterface {
     page: number;
@@ -92,4 +88,3 @@ export interface PaginationMixinInterface {
     setPage: (value: number) => void;
     setNumItemsPerPage: (value: number) => void;
 }
-export type SyncListenerFn = (instance: FinderCore) => void;

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

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

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

@@ -1,6 +1,6 @@
 import { EVENT_SOURCE, EVENTS } from "../core-constants";
 import { FinderCore } from "../finder-core";
-import { FinderRule } from "./rule-types";
+import { RuleDefinition } from "./rule-types";
 export type FinderTouchSource = (typeof EVENT_SOURCE)[keyof typeof EVENT_SOURCE];
 interface FinderSharedEventProps {
     source: string;
@@ -34,7 +34,7 @@ export interface FinderTouchEvent {
     event: FinderEventName;
     current: any;
     initial: any;
-    rule?: FinderRule;
+    rule?: RuleDefinition;
 }
 /**
  * External type that consumers will receive

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

@@ -3,71 +3,67 @@ import { FinderResultGroup, SortDirection } from "./core-types";
  * Select a property from the item to sort by.
  */
 export type FinderPropertySelector<FItem, FContext = any> = (item: FItem, context: FContext) => string | number;
-interface RuleBase {
+interface Rule {
     id: string;
     debounceMilliseconds?: number;
     label?: string;
     hidden?: boolean;
 }
-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> extends Omit<RuleBase, "id"> {
+export type RuleDefinition<FItem = any, FContext = any> = SearchRuleDefinition<FItem, FContext> | FilterRuleDefinition<FItem, FContext> | SortByRuleDefinition<FItem, FContext> | GroupByRuleDefinition<FItem, FContext>;
+export interface SearchRuleDefinition<FItem = any, FContext = any> extends Omit<Rule, "id"> {
     id?: string;
     searchFn?: (item: FItem, context: FContext) => string | string[];
 }
-export interface FilterOptionGeneratorFnOptions<FItem, FContext = any> {
-    items: FItem[];
-    context: FContext;
-}
 /**
  * Describes the display of a filter or sort option.
  */
 export interface FilterOption<FValue = any> {
-    label: string;
+    label?: string;
     value: FValue;
     disabled?: boolean;
 }
-export interface FilterRule<FItem = any, FValue = any, FContext = any> extends RuleBase {
-    options?: FilterOption<FValue>[] | ((options: FilterOptionGeneratorFnOptions<FItem, FContext>) => FilterOption<FValue>[]);
+export interface FilterRuleDefinition<FItem = any, FValue = any, FContext = any> extends Rule {
+    filterFn: (item: FItem, value: FValue, context: FContext) => boolean;
     required?: boolean;
+    strictOptions?: boolean;
+    multiple?: boolean;
+    boolean?: boolean;
+    options?: FilterOption<FValue>[] | ((options: {
+        items: FItem[];
+        context: FContext;
+    }) => FilterOption<FValue>[]);
 }
-export interface FilterRuleWithBooleanValue<FItem, FContext = any> extends FilterRule<FItem> {
+export type AnyFilterRuleDefinition<FItem = any, FValue = any> = Omit<FilterRuleDefinition<FItem, FValue>, "options">;
+export interface FilterRuleWithBooleanValue<FItem = any, FValue = boolean, FContext = any> extends FilterRuleDefinition<FItem, FValue, FContext> {
     multiple?: false;
     boolean: true;
-    filterFn: (item: FItem, value: boolean, context: FContext) => boolean;
     defaultValue?: boolean;
+    options?: never;
 }
-export interface FilterRuleWithSingleValue<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
+export interface FilterRuleWithSingleValue<FItem = any, FValue = any, FContext = any> extends FilterRuleDefinition<FItem, FValue, FContext> {
     multiple?: false;
     boolean?: false;
-    filterFn: (item: FItem, value: FValue, context: FContext) => boolean;
     defaultValue?: FValue;
 }
-export interface FilterRuleWithMultipleValues<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
+export interface FilterRuleWithMultipleValues<FItem = any, FValue = any, FContext = any> extends FilterRuleDefinition<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> | FilterRuleWithSingleValue<FItem, FValue> | FilterRuleWithMultipleValues<FItem, FValue>;
 /**
  * A hydrated filter has rendered any option generator functions, and narrowed ambiguous properties from FilterRule.
  */
-export interface HydratedFilterRule<FItem = any, FValue = any, FContext = any> extends Omit<FilterRule<FItem, FValue>, "options"> {
+export interface HydratedFilterRuleDefinition<FItem = any, FValue = any, FContext = any> extends FilterRuleDefinition<FItem, FValue, FContext> {
     options?: FilterOption<FValue>[];
-    required: boolean;
-    boolean: boolean;
-    hidden: boolean;
     multiple: boolean;
-    filterFn: ((item: FItem, value: FValue, context: FContext) => boolean) | ((item: FItem, value: FValue[], context: FContext) => boolean);
-    defaultValue?: boolean | FValue | FValue[];
+    boolean: boolean;
     _isHydrated: true;
 }
-export interface SortByRule<FItem = any, FContext = any> extends RuleBase {
+export interface SortByRuleDefinition<FItem = any, FContext = any> extends Rule {
     sortFn: FinderPropertySelector<FItem, FContext> | FinderPropertySelector<FItem, FContext>[];
     defaultSortDirection?: SortDirection;
 }
-export interface GroupByRule<FItem = any, FContext = any> extends RuleBase {
+export interface GroupByRuleDefinition<FItem = any, FContext = any> extends Rule {
     groupFn: FinderPropertySelector<FItem, FContext>;
     sortGroupFn?: FinderPropertySelector<FinderResultGroup<FItem>, FContext>;
     defaultGroupSortDirection?: SortDirection;
@@ -77,16 +73,16 @@ export interface GroupByRule<FItem = any, FContext = any> extends RuleBase {
     };
 }
 export interface SearchTestOptions {
-    rule: SearchRule[];
+    rule: SearchRuleDefinition[];
     searchTerm: string;
 }
 export interface FilterTestOptions {
-    rules: HydratedFilterRule[];
+    rules: HydratedFilterRuleDefinition[];
     values?: Record<string, any>;
     isAdditive?: boolean;
 }
 export interface FilterTestRuleOptions {
-    rule: string | FilterRuleUnion | HydratedFilterRule;
+    rule: string | AnyFilterRuleDefinition;
     value: any;
     isAdditive?: boolean;
 }

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

@@ -1,15 +1,18 @@
 import { FinderCore } from "../finder-core";
 import { RuleEffect, SearchEffect } from "../types/effect-types";
-import { FilterRuleWithBooleanValue, FilterRuleWithMultipleValues, FilterRuleWithSingleValue, FinderRule, GroupByRule, SearchRule, SortByRule } from "../types/rule-types";
+import { FilterRuleWithBooleanValue, FilterRuleWithMultipleValues, FilterRuleWithSingleValue, RuleDefinition, GroupByRuleDefinition, SearchRuleDefinition, SortByRuleDefinition, AnyFilterRuleDefinition } from "../types/rule-types";
 /**
  * Enforce structure for an array of rule of mixed types.
  */
-export declare function finderRuleset<FItem, FContext = any>(rules: FinderRule<FItem, FContext>[]): FinderRule<FItem, FContext>[];
-export declare function searchRule<FItem, FContext = any>(rule: SearchRule<FItem, FContext>): SearchRule<FItem, FContext>;
+export declare function finderRuleset<FItem, FContext = any>(rules: RuleDefinition<FItem, FContext>[]): RuleDefinition<FItem, FContext>[];
+export declare function searchRule<FItem, FContext = any>(rule: SearchRuleDefinition<FItem, FContext>): SearchRuleDefinition<FItem, FContext>;
 export declare function filterRule<FItem, FValue = any, FContext = any, T = FilterRuleWithMultipleValues<FItem, FValue, FContext>>(rule: T): FilterRuleWithMultipleValues<FItem, FValue>;
-export declare function filterRule<FItem, FValue = any, FContext = any, T = FilterRuleWithBooleanValue<FItem, FContext>>(rule: T): FilterRuleWithBooleanValue<FItem, FValue>;
+export declare function filterRule<FItem, FValue = boolean, FContext = any, T = FilterRuleWithBooleanValue<FItem, FValue, FContext>>(rule: T): FilterRuleWithBooleanValue<FItem, FValue>;
 export declare function filterRule<FItem, FValue = any, FContext = any, T = FilterRuleWithSingleValue<FItem, FValue, FContext>>(rule: T): FilterRuleWithSingleValue<FItem, FValue>;
-export declare function sortByRule<FItem, FContext = any>(rule: SortByRule<FItem, FContext>): SortByRule<FItem, FContext>;
-export declare function groupByRule<FItem, FContext = any>(rule: GroupByRule<FItem, FContext>): GroupByRule<FItem, FContext>;
-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>, rule: FinderRule) => void): RuleEffect<FItem, FContext>;
+export declare function sortByRule<FItem, FContext = any>(rule: SortByRuleDefinition<FItem, FContext>): SortByRuleDefinition<FItem, FContext>;
+export declare function groupByRule<FItem, FContext = any>(rule: GroupByRuleDefinition<FItem, FContext>): GroupByRuleDefinition<FItem, FContext>;
+export declare function ruleEffect<FItem, FContext = any>(rules: string | RuleDefinition<FItem> | (string | RuleDefinition<FItem>)[] | ((items: FItem[], context: FContext) => string | RuleDefinition<FItem> | (string | RuleDefinition<FItem>)[]), onChange: (instance: FinderCore<FItem, FContext>, rule: RuleDefinition) => 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>, searchTerm: string) => void): SearchEffect<FItem, FContext>;
+export declare function transformFilterToSingleValue<FItem, FValue, FContext = any>(filter: AnyFilterRuleDefinition<FItem, FValue>): FilterRuleWithMultipleValues<FItem, FValue, FContext>;
+export declare function transformFilterToBoolean<FItem, FValue, FContext = any>(filter: AnyFilterRuleDefinition<FItem, FValue>): FilterRuleWithBooleanValue<FItem, boolean, FContext>;
+export declare function transformFilterToMultiple<FItem, FValue, FContext = any>(filter: AnyFilterRuleDefinition<FItem, FValue>): FilterRuleWithMultipleValues<FItem, FValue, FContext>;