@hitgrab/finder 0.0.26-alpha → 0.1.3-alpha

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

@@ -0,0 +1,104 @@
+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;
+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;
+    hidden?: boolean;
+    debounceMilliseconds?: number;
+    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;
+    value: FValue;
+    disabled?: boolean;
+}
+export interface FilterRule<FItem = any, FValue = any, FContext = any> {
+    id: string;
+    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;
+    boolean: true;
+    filterFn: (item: FItem, value: boolean, context?: FContext) => boolean;
+    defaultValue?: boolean;
+}
+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;
+}
+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> | 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"> {
+    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[];
+    _isHydrated: true;
+}
+export interface SortByRule<FItem = any, FContext = any> {
+    id: string;
+    sortFn: FinderPropertySelector<FItem, FContext> | FinderPropertySelector<FItem, FContext>[];
+    defaultSortDirection?: SortDirection;
+    label?: string;
+    hidden?: boolean;
+}
+export interface GroupByRule<FItem = any, FContext = any> {
+    id: string;
+    groupFn: FinderPropertySelector<FItem, FContext>;
+    sortGroupFn?: FinderPropertySelector<FinderResultGroup<FItem>, FContext>;
+    defaultGroupSortDirection?: SortDirection;
+    sticky?: {
+        header?: string | string[];
+        footer?: string | string[];
+    };
+    label?: string;
+    hidden?: boolean;
+}
+export interface SearchTestOptions {
+    rule: SearchRule[];
+    searchTerm: string;
+}
+export interface FilterTestOptions {
+    rules: HydratedFilterRule[];
+    values?: Record<string, any>;
+    isAdditive?: boolean;
+}
+export interface FilterTestRuleOptions {
+    rule: string | FilterRuleUnion | HydratedFilterRule;
+    value: any;
+    isAdditive?: boolean;
+}
+export interface FilterTestRuleOptionsOptions {
+    rule: string | FilterRuleUnion | HydratedFilterRule;
+    isAdditive?: boolean;
+    mergeExistingValue?: boolean;
+}

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,9 +1,15 @@
-import { SearchRule, SortByRule, GroupByRule, FilterRuleUnion } from "../../types";
+import { FinderCore } from "../finder-core";
+import { RuleEffect, SearchEffect } from "../types/effect-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: (SearchRule<FItem> | FilterRuleUnion<FItem, any> | SortByRule<FItem> | GroupByRule<FItem>)[]): (SearchRule<FItem> | FilterRuleUnion<FItem, any> | SortByRule<FItem> | GroupByRule<FItem>)[];
-export declare function searchRule<FItem>(rule: SearchRule<FItem>): SearchRule<FItem>;
-export declare function filterRule<FItem, FValue = any>(rule: FilterRuleUnion<FItem, FValue>): FilterRuleUnion<FItem, FValue>;
-export declare function sortByRule<FItem>(rule: SortByRule<FItem>): SortByRule<FItem>;
-export declare function groupByRule<FItem>(rule: GroupByRule<FItem>): GroupByRule<FItem>;
+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, 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): SearchEffect<FItem, FContext>;

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

@@ -1,14 +1,9 @@
-import { FilterOption, FinderRule, GroupByRule, HydratedFilterRule, SearchRule, SortByRule, MetaInterface, FilterRuleUnion } from "../../types";
-/**
- * Make sure the passed ruleset contains only well-configured rules.
- */
-export declare function isValidRuleset(rules?: FinderRule[]): rules is FinderRule[];
-export declare function getRuleFromIdentifier<T extends FinderRule>(identifier: FinderRule | string | undefined, rules: T[]): T | undefined;
-export declare function getFilterOptionFromIdentifier<FItem>(optionOrOptionValue: FilterOption | any, options: FilterOption[] | ((items: FItem[], meta: MetaInterface) => FilterOption[]) | undefined, items: FItem[], meta: MetaInterface): any;
-export declare function isFilterOption(data: unknown): data is FilterOption;
-export declare function getRuleType(rule: FinderRule): "search" | "filter" | "sortBy" | "groupBy";
+import { RuleEffect, SearchEffect } from "../types/effect-types";
+import { FilterRuleUnion, GroupByRule, HydratedFilterRule, SearchRule, SortByRule } from "../types/rule-types";
 export declare function isSortByRule<FItem>(rule: unknown): rule is SortByRule<FItem>;
 export declare function isSearchRule<FItem>(rule: unknown): rule is SearchRule<FItem>;
-export declare function isFilterUnionRule<FItem>(rule: unknown): rule is FilterRuleUnion<FItem>;
+export declare function isFilterRule<FItem>(rule: unknown): rule is FilterRuleUnion<FItem>;
 export declare function isHydratedFilterRule<FItem>(rule: unknown): rule is HydratedFilterRule<FItem>;
 export declare function isGroupByRule<FItem>(rule: unknown): rule is GroupByRule<FItem>;
+export declare function isRuleEffect<FItem>(data: unknown): data is RuleEffect<FItem>;
+export declare function isSearchEffect<FItem>(data: unknown): data is SearchEffect<FItem>;

package/dist/index.d.ts

@@ -1,20 +1,14 @@
-/** Vanilla JS library */
-export { FinderPlugin } from "./core/plugins/plugin-super-class";
-export { finderRuleset, searchRule, filterRule, sortByRule, groupByRule } from "./core/utils/rule-type-enforcers";
-export { finderStringCompare, finderCharacterCompare, finderSequentialCharacterCompare } from "./core/utils/string-compare-utils";
-export type { FinderSnapshot, FinderConstructorOptions, FinderRule, SearchRule, FilterRule, HydratedFilterRule, FilterRuleUnion, SortByRule, GroupByRule, FinderResultGroup, FilterOption, SortDirection, FinderEvent, FinderInitEvent, FinderReadyEvent, FinderFirstUserInteractionEvent, FinderChangeEvent, LayoutVariant, FinderPluginFn, FinderPluginInterface, } from "./types";
+export type { FinderConstructorOptions, FinderResultGroup, SortDirection } from "./core/types/core-types";
+export { finderRuleset, searchRule, filterRule, sortByRule, groupByRule, ruleEffect, searchEffect } from "./core/utils/rule-type-enforcers";
+export type { FinderRule, SearchRule, SortByRule, GroupByRule, FilterRule, HydratedFilterRule, FilterRuleUnion, FilterOption } from "./core/types/rule-types";
+export type { RuleEffect, SearchEffect } from "./core/types/effect-types";
+export type { FinderEvent, FinderInitEvent, FinderReadyEvent, FinderFirstUserInteractionEvent, FinderChangeEvent } from "./core/types/event-types";
+export type { StringMatchSegment } from "./core/types/string-match-types";
 /**
  * React hooks and components
  */
 export { useFinder } from "./react/hooks/use-finder";
-export { useFinderContext } from "./react/hooks/use-finder-context";
-export { FinderItems } from "./react/components/finder-items";
 export { Finder } from "./react/components/finder";
-export { FinderEmpty } from "./react/components/finder-empty";
-export { FinderGroups } from "./react/components/finder-groups";
-export { FinderLoading } from "./react/components/finder-loading";
-export { FinderNoMatches } from "./react/components/finder-no-matches";
-export { FinderContent } from "./react/components/finder-content";
-export { FinderSearchTerm } from "./react/components/finder-search-term";
 export { useFinderRef } from "./react/hooks/use-finder-ref";
-export type { FinderProps, FinderContentComponentProps, FinderGroupsComponentProps, FinderItemsComponentProps } from "./react/types/react-types";
+export { StringMatch } from "./react/components/string-match";
+export type { FinderProps, FinderContentProps, FinderContentGroupProps, FinderContentItemProps, StringMatchSegmentProps } from "./react/types/react-types";