@hitgrab/finder 0.0.26-alpha → 0.1.0-alpha

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

@@ -0,0 +1,22 @@
+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;
+    exact?: boolean;
+}
+export interface HydratedSearchEffect<FItem = any, FContext = any> {
+    haystack: string[];
+    onChange: (instance: FinderCore<FItem, FContext>) => void;
+    exact: boolean;
+    _isHydrated: true;
+}

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

@@ -0,0 +1,43 @@
+import { FinderSnapshot } from "./core-types";
+import { FinderRule } from "./rule-types";
+export type FinderTouchSource = "core" | "filters" | "groupBy" | "pagination" | "search" | "sortBy";
+interface FinderSharedEventProps {
+    source: string;
+    event: FinderEventName;
+    snapshot: FinderSnapshot<any>;
+    timestamp: number;
+}
+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 = "init" | "firstUserInteraction" | "ready" | "change" | "change.core" | "change.core.setIsLoading" | "change.core.setIsDisabled" | "change.core.setItems" | "change.core.syncContext" | `change.filters` | "change.filters.set" | `change.groupBy` | "change.groupBy.set" | "change.groupBy.setGroupIdSortDirection" | "change.pagination" | "change.pagination.setPage" | "change.pagination.setNumItemsPerPage" | "change.search" | "change.search.setSearchTerm" | "change.search.reset" | "change.sortBy" | "change.sortBy.set" | "change.sortBy.setSortDirection";
+export {};

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

@@ -0,0 +1,108 @@
+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 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;
+    multiple?: boolean;
+    boolean?: boolean;
+    filterFn: CallableFunction;
+    defaultValue?: any;
+}
+interface FilterRuleWithBooleanValue<FItem, FValue = boolean, FContext = any> extends FilterRule<FItem, FValue> {
+    multiple?: false;
+    boolean: true;
+    filterFn: (item: FItem, value: FValue, context?: FContext) => boolean;
+    defaultValue?: boolean;
+}
+interface FilterRuleWithScalarValue<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
+    multiple?: false;
+    boolean?: false;
+    filterFn: (item: FItem, value: FValue, context?: FContext) => boolean;
+    defaultValue?: FValue;
+}
+interface FilterRuleWithMultipleValues<FItem, FValue, FContext = any> extends FilterRule<FItem, FValue, FContext> {
+    multiple: true;
+    boolean?: false;
+    filterFn: (item: FItem, value: FValue[], context?: FContext) => boolean;
+    defaultValue?: FValue[];
+}
+export type FilterRuleUnion<FItem = any, FValue = any> = FilterRuleWithBooleanValue<FItem> | FilterRuleWithScalarValue<FItem, FValue> | FilterRuleWithMultipleValues<FItem, FValue>;
+/**
+ * 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>;
+    sortGroupIdFn?: FinderPropertySelector<FinderResultGroup<FItem>, FContext>;
+    groupIdSortDirection?: 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;
+}
+export {};

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

@@ -1,9 +1,13 @@
-import { SearchRule, SortByRule, GroupByRule, FilterRuleUnion } from "../../types";
+import { FinderCore } from "../finder-core";
+import { RuleEffect, SearchEffect } from "../types/effect-types";
+import { FilterRuleUnion, 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 finderRuleset<FItem>(rules: FinderRule<FItem>[]): FinderRule<FItem>[];
+export declare function searchRule<FItem>(rule: SearchRule<FItem>): SearchRule<FItem, any>;
 export declare function filterRule<FItem, FValue = any>(rule: FilterRuleUnion<FItem, FValue>): FilterRuleUnion<FItem, FValue>;
-export declare function sortByRule<FItem>(rule: SortByRule<FItem>): SortByRule<FItem>;
-export declare function groupByRule<FItem>(rule: GroupByRule<FItem>): GroupByRule<FItem>;
+export declare function sortByRule<FItem>(rule: SortByRule<FItem>): SortByRule<FItem, any>;
+export declare function groupByRule<FItem>(rule: GroupByRule<FItem>): GroupByRule<FItem, any>;
+export declare function ruleEffect<FItem, FContext = any>(rules: string | FinderRule<FItem> | (string | FinderRule<FItem>)[] | ((items: FItem[], context: FContext) => string | FinderRule<FItem> | (string | FinderRule<FItem>)[]), onChange: (instance: FinderCore<FItem, FContext>) => void): RuleEffect<FItem, FContext>;
+export declare function searchEffect<FItem, FContext = any>(haystack: string | string[] | ((items: FItem[], context: FContext) => string | string[]), onChange: (instance: FinderCore<FItem, FContext>) => void, exact?: boolean): SearchEffect<FItem, FContext>;

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

@@ -1,14 +1,11 @@
-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;
+import { RuleEffect, SearchEffect } from "../types/effect-types";
+import { FilterOption, FilterRuleUnion, GroupByRule, HydratedFilterRule, SearchRule, SortByRule } from "../types/rule-types";
+export declare function getFilterOptionFromIdentifier<FItem, FContext>(optionOrOptionValue: FilterOption | any, options: FilterOption[] | ((items: FItem[], context?: FContext) => FilterOption[]) | undefined, items: FItem[], context?: FContext): any;
 export declare function isFilterOption(data: unknown): data is FilterOption;
-export declare function getRuleType(rule: FinderRule): "search" | "filter" | "sortBy" | "groupBy";
 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 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,12 @@
-/** 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 { FinderSnapshot, FinderConstructorOptions, FinderResultGroup, SortDirection } from "./core/types/core-types";
+export type { FinderRule, SearchRule, SortByRule, GroupByRule, FilterRule, HydratedFilterRule, FilterRuleUnion, FilterOption } from "./core/types/rule-types";
+export { finderRuleset, searchRule, filterRule, sortByRule, groupByRule, ruleEffect, searchEffect } from "./core/utils/rule-type-enforcers";
+export type { RuleEffect, SearchEffect } from "./core/types/effect-types";
+export type { FinderEvent, FinderInitEvent, FinderReadyEvent, FinderFirstUserInteractionEvent, FinderChangeEvent } from "./core/types/event-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 type { FinderProps, FinderContentProps, FinderContentGroupProps, FinderContentItemProps } from "./react/types/react-types";