@hitgrab/finder 0.1.5-alpha → 0.1.7-alpha

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

@@ -29,9 +29,15 @@ export declare const ERRORS: {
     RULE_NOT_FOUND: string;
     WRONG_RULE_TYPE_FOR_MIXIN: string;
     NO_SEARCH_RULE_SET: string;
+    SETTING_MULTIPLE_FILTER_WITHOUT_ARRAY: string;
+    ADDING_OPTION_TO_MULTIPLE_FILTER_WITHOUT_OPTION_VALUE: string;
+    DELETING_OPTION_VALUE_FROM_NON_MULTIPLE_FILTER: string;
+    SETTING_BOOLEAN_FILTER_WITHOUT_BOOLEAN_VALUE: string;
+    ADDING_OPTION_VALUE_TO_NON_MULTIPLE_FILTER: string;
     TOGGLING_OPTION_ON_RULE_WITH_NO_OPTIONS: string;
     TOGGLING_OPTION_ON_RULE_WITH_SINGLE_VALUE: string;
     TOGGLING_OPTION_THAT_DOES_NOT_EXIST: string;
+    TOGGLING_OPTION_WITHOUT_PASSING_OPTION: 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,7 +1,3 @@
-declare class DebounceCallbackRegistry {
-    #private;
-    register(id: string, delay?: number): void;
-    has(id: string): boolean;
-    call(id: string, callback: CallableFunction): void;
-}
+import { FinderRule } from "./types/rule-types";
+declare function DebounceCallbackRegistry(): (rule: FinderRule, callback: () => void) => any;
 export { DebounceCallbackRegistry };

package/dist/core/filter-utils/boolean-filter.d.ts

@@ -0,0 +1,10 @@
+import { HydratedFilterRule } from "../types/rule-types";
+export declare function BooleanFilter(rule: HydratedFilterRule): {
+    validate(value: unknown): boolean;
+    parse(value: unknown): any;
+    has(value: unknown): any;
+    toggle(value: unknown, optionValue?: any): boolean;
+    add(value: unknown, optionValue: any): never;
+    delete(value: unknown, optionValue?: any): undefined;
+    isActive(value: unknown): boolean;
+};

package/dist/core/filter-utils/filter-factory.d.ts

@@ -0,0 +1,18 @@
+import { HydratedFilterRule } from "../types/rule-types";
+export declare function makeFilter(rule: HydratedFilterRule): {
+    validate(value: unknown): boolean;
+    parse(value: unknown): any;
+    has(value: unknown): any;
+    toggle(value: unknown, optionValue?: any): boolean;
+    add(value: unknown, optionValue: any): never;
+    delete(value: unknown, optionValue?: any): undefined;
+    isActive(value: 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;
+};

package/dist/core/filter-utils/multiple-filter.d.ts

@@ -0,0 +1,10 @@
+import { HydratedFilterRule } from "../types/rule-types";
+export declare function MultipleFilter(rule: HydratedFilterRule): {
+    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;
+};

package/dist/core/filter-utils/single-filter.d.ts

@@ -0,0 +1,10 @@
+import { HydratedFilterRule } from "../types/rule-types";
+export declare function SingleFilter(rule: HydratedFilterRule): {
+    validate(): 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;
+};

package/dist/core/filters.d.ts

@@ -7,22 +7,22 @@ type FilterRuleIdentifier = string | FilterRuleUnion | HydratedFilterRule;
 declare class FiltersMixin {
     #private;
     constructor({ initialFilters }: InitialValues, deps: MixinInjectedDependencies);
-    set<FValue>(identifier: FilterRuleIdentifier, incomingFilterValue: FValue | FValue[]): void;
+    set<FValue>(identifier: FilterRuleIdentifier, value: FValue | FValue[]): void;
     get rules(): HydratedFilterRule<unknown, any, any>[];
     get activeRules(): HydratedFilterRule<unknown, any, any>[];
     get(identifier: FilterRuleIdentifier): any;
-    has(identifier: FilterRuleIdentifier, optionValue?: any): any;
+    has(identifier: FilterRuleIdentifier, optionValue?: any): boolean;
     getRule(identifier: FilterRuleIdentifier): HydratedFilterRule<any, any, any>;
-    delete(identifier: FilterRuleIdentifier): void;
+    add(identifier: FilterRuleIdentifier, optionValue: any): void;
+    delete(identifier: FilterRuleIdentifier, optionValue?: any): 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>;
+    get values(): Record<string, any>;
+    get raw(): 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.d.ts

@@ -29,7 +29,7 @@ declare class FinderCore<FItem = any, FContext = any> {
         searchTerm: string;
         hasSearchTerm: boolean;
         hasSearchRule: boolean;
-        setSearchTerm: (incomingSearchTerm: string) => void;
+        setSearchTerm: (value: string) => void;
         reset: () => void;
         test: (searchTerm: string, isAdditive?: boolean) => FItem[];
     };
@@ -40,11 +40,12 @@ declare class FinderCore<FItem = any, FContext = 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) => 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>, incomingFilterValue: FValue | FValue[]) => void;
-        delete: (identifier: string | import("..").FilterRuleUnion | import("..").HydratedFilterRule<any, any, 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;
         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>;

package/dist/core/search.d.ts

@@ -9,7 +9,7 @@ declare class SearchMixin<FItem> {
     get rule(): import("..").SearchRule<unknown, any> | undefined;
     get hasSearchRule(): boolean;
     get hasSearchTerm(): boolean;
-    setSearchTerm(incomingSearchTerm: string): void;
+    setSearchTerm(value: string): void;
     reset(): void;
     serialize(): SerializedSearchMixin;
     test(searchTerm: string, isAdditive?: boolean): FItem[];

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

@@ -42,7 +42,7 @@ export interface MixinInjectedDependencies<FItem = any, FContext = any> {
     touch: FinderTouchCallback;
     getItems: () => FItem[];
     test: (serializedMixins: SnapshotSerializedMixins, isAdditive?: boolean) => FItem[];
-    debouncer: DebounceCallbackRegistry;
+    debouncer: ReturnType<typeof DebounceCallbackRegistry>;
 }
 export type EventCallback = (payload?: any) => void;
 export interface SnapshotOptions<FItem, FContext> {

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

@@ -2,19 +2,19 @@ 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;
+    onChange: (instance: FinderCore<FItem, FContext>, rule: FinderRule<FItem>) => void;
 }
 export interface HydratedRuleEffect<FItem = any, FContext = any> {
     rules: (string | FinderRule<FItem>)[];
-    onChange: (instance: FinderCore<FItem, FContext>) => void;
+    onChange: (instance: FinderCore<FItem, FContext>, rule: FinderRule<FItem>) => 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;
+    onChange: (instance: FinderCore<FItem, FContext>, searchTerm: string) => void;
 }
 export interface HydratedSearchEffect<FItem = any, FContext = any> {
     haystack: string[];
-    onChange: (instance: FinderCore<FItem, FContext>) => void;
+    onChange: (instance: FinderCore<FItem, FContext>, searchTerm: string) => void;
     _isHydrated: true;
 }

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

@@ -3,13 +3,16 @@ 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 {
+    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> {
+export interface SearchRule<FItem = any, FContext = any> extends Omit<RuleBase, "id"> {
     id?: string;
-    label?: string;
-    hidden?: boolean;
-    debounceMilliseconds?: number;
     searchFn?: (item: FItem, context?: FContext) => string | string[];
 }
 export interface FilterOptionGeneratorFnOptions<FItem, FContext = any> {
@@ -24,13 +27,9 @@ export interface FilterOption<FValue = any> {
     value: FValue;
     disabled?: boolean;
 }
-export interface FilterRule<FItem = any, FValue = any, FContext = any> {
-    id: string;
+export interface FilterRule<FItem = any, FValue = any, FContext = any> extends RuleBase {
     options?: FilterOption<FValue>[] | ((options: FilterOptionGeneratorFnOptions<FItem, FContext>) => FilterOption<FValue>[]);
     required?: boolean;
-    label?: string;
-    hidden?: boolean;
-    debounceMilliseconds?: number;
 }
 export interface FilterRuleWithBooleanValue<FItem, FContext = any> extends FilterRule<FItem> {
     multiple?: false;
@@ -64,15 +63,11 @@ export interface HydratedFilterRule<FItem = any, FValue = any, FContext = any> e
     defaultValue?: boolean | FValue | FValue[];
     _isHydrated: true;
 }
-export interface SortByRule<FItem = any, FContext = any> {
-    id: string;
+export interface SortByRule<FItem = any, FContext = any> extends RuleBase {
     sortFn: FinderPropertySelector<FItem, FContext> | FinderPropertySelector<FItem, FContext>[];
     defaultSortDirection?: SortDirection;
-    label?: string;
-    hidden?: boolean;
 }
-export interface GroupByRule<FItem = any, FContext = any> {
-    id: string;
+export interface GroupByRule<FItem = any, FContext = any> extends RuleBase {
     groupFn: FinderPropertySelector<FItem, FContext>;
     sortGroupFn?: FinderPropertySelector<FinderResultGroup<FItem>, FContext>;
     defaultGroupSortDirection?: SortDirection;
@@ -80,8 +75,6 @@ export interface GroupByRule<FItem = any, FContext = any> {
         header?: string | string[];
         footer?: string | string[];
     };
-    label?: string;
-    hidden?: boolean;
 }
 export interface SearchTestOptions {
     rule: SearchRule[];
@@ -102,3 +95,4 @@ export interface FilterTestRuleOptionsOptions {
     isAdditive?: boolean;
     mergeExistingValue?: boolean;
 }
+export {};

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

@@ -11,5 +11,5 @@ export declare function filterRule<FItem, FValue = any, T = FilterRuleWithBoolea
 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): SearchEffect<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 searchEffect<FItem, FContext = any>(haystack: string | string[] | ((items: FItem[], context: FContext) => string | string[]), onChange: (instance: FinderCore<FItem, FContext>, searchTerm: string) => void): SearchEffect<FItem, FContext>;