@hitgrab/finder 0.0.26-alpha → 0.1.0-alpha

package/dist/react/components/finder-content-empty.d.ts

@@ -0,0 +1,6 @@
+import { FinderContentRenderProp } from "../types/react-types";
+interface FinderContentEmptyProps {
+    children: FinderContentRenderProp;
+}
+declare function FinderContentEmpty({ children: Component }: FinderContentEmptyProps): Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null;
+export { FinderContentEmpty };

package/dist/react/components/finder-content-groups.d.ts

@@ -0,0 +1,7 @@
+import { ElementType } from "react";
+import { FinderContentGroupProps } from "../types/react-types";
+interface FinderContentGroupsProps<FItem = any> {
+    children: ElementType<FinderContentGroupProps<FItem>>;
+}
+declare function FinderContentGroups<FItem>({ children: Component }: FinderContentGroupsProps<FItem>): import("react/jsx-runtime").JSX.Element | null;
+export { FinderContentGroups };

package/dist/react/components/finder-content-items.d.ts

@@ -0,0 +1,7 @@
+import { ElementType } from "react";
+import { FinderContentItemProps } from "../types/react-types";
+interface FinderContentItemsProps<FItem = any> {
+    children: ElementType<FinderContentItemProps<FItem>>;
+}
+declare function FinderContentItems<FItem>({ children: Component }: FinderContentItemsProps<FItem>): import("react/jsx-runtime").JSX.Element | null;
+export { FinderContentItems };

package/dist/react/components/finder-content-loading.d.ts

@@ -0,0 +1,6 @@
+import { FinderContentRenderProp } from "../types/react-types";
+interface FinderContentLoadingProps {
+    children: FinderContentRenderProp;
+}
+declare function FinderContentLoading({ children: Component }: FinderContentLoadingProps): Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null;
+export { FinderContentLoading };

package/dist/react/components/finder-content-no-matches.d.ts

@@ -0,0 +1,6 @@
+import { FinderContentRenderProp } from "../types/react-types";
+interface FinderContentNoMatchesProps {
+    children: FinderContentRenderProp;
+}
+declare function FinderContentNoMatches({ children: Component }: FinderContentNoMatchesProps): Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null;
+export { FinderContentNoMatches };

package/dist/react/components/finder-content.d.ts

@@ -1,13 +1,25 @@
 import { ElementType } from "react";
-import { FinderBaseRenderProp, FinderItemsComponentProps, FinderGroupsComponentProps } from "../types/react-types";
-interface FinderContentProps<FItem> {
+import { FinderContentRenderProp, FinderContentItemProps, FinderContentGroupProps } from "../types/react-types";
+import { FinderContentLoading } from "./finder-content-loading";
+import { FinderContentEmpty } from "./finder-content-empty";
+import { FinderContentNoMatches } from "./finder-content-no-matches";
+import { FinderContentItems } from "./finder-content-items";
+import { FinderContentGroups } from "./finder-content-groups";
+interface FinderContentProps<FItem, FContext> {
     children: {
-        loading?: FinderBaseRenderProp;
-        empty?: FinderBaseRenderProp;
-        noMatches?: FinderBaseRenderProp;
-        items?: ElementType<FinderItemsComponentProps<FItem>>;
-        groups?: ElementType<FinderGroupsComponentProps<FItem>>;
+        loading?: FinderContentRenderProp;
+        empty?: FinderContentRenderProp;
+        noMatches?: FinderContentRenderProp;
+        items?: ElementType<FinderContentItemProps<FItem, FContext>>;
+        groups?: ElementType<FinderContentGroupProps<FItem, FContext>>;
     };
 }
-declare function FinderContent<FItem = any>({ children: renderProps }: FinderContentProps<FItem>): (import("react/jsx-runtime").JSX.Element | undefined)[];
+declare function FinderContent<FItem = any, FContext = any>({ children: renderProps }: FinderContentProps<FItem, FContext>): (import("react/jsx-runtime").JSX.Element | undefined)[];
+declare namespace FinderContent {
+    var Loading: typeof FinderContentLoading;
+    var Empty: typeof FinderContentEmpty;
+    var NoMatches: typeof FinderContentNoMatches;
+    var Items: typeof FinderContentItems;
+    var Groups: typeof FinderContentGroups;
+}
 export { FinderContent };

package/dist/react/components/finder-search-term.d.ts

@@ -2,6 +2,7 @@ import { ElementType } from "react";
 interface FinderSearchTermProps {
     children: string;
     Component?: ElementType;
+    searchTerm?: string;
 }
-declare function FinderSearchTerm({ Component, children }: FinderSearchTermProps): string | import("react/jsx-runtime").JSX.Element;
+declare function FinderSearchTerm({ Component, searchTerm, children }: FinderSearchTermProps): string | (string | import("react/jsx-runtime").JSX.Element)[];
 export { FinderSearchTerm };

package/dist/react/components/finder.d.ts

@@ -1,3 +1,9 @@
 import { FinderProps } from "../types/react-types";
-declare function Finder<FItem = any>({ items, rules, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialFilters, initialMeta, initialSelectedItems, maxSelectedItems, isLoading, disabled, page, numItemsPerPage, requireGroup, layoutVariants, initialLayout, plugins, onInit, onReady, onFirstUserInteraction, onChange, children, controllerRef, }: FinderProps<FItem>): import("react/jsx-runtime").JSX.Element;
+import { FinderContent } from "./finder-content";
+import { FinderSearchTerm } from "./finder-search-term";
+declare function Finder<FItem = any, FContext = any>({ items, rules, effects, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialFilters, context, isLoading, disabled, page, numItemsPerPage, requireGroup, ignoreSortByRulesWhileSearchRuleIsActive, onInit, onReady, onFirstUserInteraction, onChange, controllerRef, children, }: FinderProps<FItem, FContext>): import("react/jsx-runtime").JSX.Element;
+declare namespace Finder {
+    var Content: typeof FinderContent;
+    var SearchTerm: typeof FinderSearchTerm;
+}
 export { Finder };

package/dist/react/hooks/use-finder-constructor.d.ts

@@ -0,0 +1,7 @@
+import { FinderCore } from "../../core/finder-core";
+import { FinderConstructorOptions } from "../../core/types/core-types";
+/**
+ * Create a finder instance with contained state and controllers.
+ */
+declare function useFinderConstructor<FItem>(items: FItem[] | null | undefined, { rules, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialFilters, context, page, numItemsPerPage, isLoading, disabled, requireGroup, onInit, onReady, onFirstUserInteraction, onChange, }: FinderConstructorOptions<FItem>): FinderCore<FItem>;
+export { useFinderConstructor };

package/dist/react/hooks/use-finder-ref.d.ts

@@ -1,2 +1,2 @@
 import { FinderCore } from "../../core/finder-core";
-export declare function useFinderRef(): import("react").RefObject<FinderCore<any> | null>;
+export declare function useFinderRef<FItem = any, FContext = any>(): import("react").RefObject<FinderCore<FItem, FContext> | null>;

package/dist/react/hooks/use-finder.d.ts

@@ -1,7 +1,3 @@
-import { FinderConstructorOptions } from "../../types";
 import { FinderCore } from "../../core/finder-core";
-/**
- * Create a finder instance with contained state and controllers.
- */
-declare function useFinder<FItem>(items: FItem[] | null | undefined, { rules, initialSearchTerm, initialSortBy, initialSortDirection, initialGroupBy, initialFilters, initialSelectedItems, initialMeta, page, numItemsPerPage, layoutVariants, initialLayout, plugins, isLoading, disabled, requireGroup, maxSelectedItems, onInit, onReady, onFirstUserInteraction, onChange, }: FinderConstructorOptions<FItem>): FinderCore<FItem>;
+declare function useFinder<FItem = any, FContext = undefined>(): FinderCore<FItem, FContext>;
 export { useFinder };

package/dist/react/providers/finder-core-context.d.ts

@@ -0,0 +1,3 @@
+import { FinderCore } from "../../core/finder-core";
+declare const FinderCoreContext: import("react").Context<[FinderCore<any, any>, number | undefined] | null>;
+export { FinderCoreContext };

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

@@ -2,27 +2,23 @@
  * React-specific types for creating consumer components.
  */
 import { ElementType, PropsWithChildren, ReactElement, ReactNode, RefObject } from "react";
-import { FinderConstructorOptions, FinderResultGroup, GroupByRule } from "../../types";
 import { paginationInterface } from "../../core/pagination/pagination-interface";
-import { selectedItemsInterface } from "../../core/selected-items/selected-items-interface";
-import { metaInterface } from "../../core/meta/meta-interface";
-import { layoutInterface } from "../../core/layout/layout-interface";
 import { FinderCore } from "../../core/finder-core";
-export interface FinderProps<FItem> extends FinderConstructorOptions<FItem>, PropsWithChildren {
+import { GroupByRule } from "../../core/types/rule-types";
+import { FinderConstructorOptions, FinderResultGroup } from "../../core/types/core-types";
+export interface FinderProps<FItem, FContext> extends FinderConstructorOptions<FItem, FContext>, PropsWithChildren {
     items: FItem[] | undefined | null;
-    controllerRef?: RefObject<FinderCore<FItem> | null>;
+    controllerRef?: RefObject<FinderCore<FItem, FContext> | null>;
 }
-export interface FinderContentComponentProps {
+export interface FinderContentProps<FContext = any> {
     pagination: ReturnType<typeof paginationInterface>;
-    meta: ReturnType<typeof metaInterface>;
-    selectedItems: ReturnType<typeof selectedItemsInterface>;
-    layout: ReturnType<typeof layoutInterface>;
+    context?: FContext;
 }
-export interface FinderItemsComponentProps<FItem> extends FinderContentComponentProps {
+export interface FinderContentItemProps<FItem, FContext = any> extends FinderContentProps<FContext> {
     items: FItem[];
 }
-export interface FinderGroupsComponentProps<FItem> extends FinderContentComponentProps {
+export interface FinderContentGroupProps<FItem, FContext = any> extends FinderContentProps<FContext> {
     groups: FinderResultGroup<FItem>[];
     rule: GroupByRule;
 }
-export type FinderBaseRenderProp = ElementType<FinderContentComponentProps> | ReactElement<FinderContentComponentProps> | Iterable<ReactNode>;
+export type FinderContentRenderProp = ElementType<FinderContentProps> | ReactElement<FinderContentProps> | Iterable<ReactNode>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hitgrab/finder",
-    "version": "0.0.26-alpha",
+    "version": "0.1.0-alpha",
     "description": "Headless datatables for things that aren't tables.",
     "type": "module",
     "files": [
@@ -25,6 +25,9 @@
     "scripts": {
         "dev": "vite",
         "build": "vite build && tsc --project tsconfig.production.json",
+        "build:docs": "npm --prefix docusaurus run build && rm -r docs && cp -r ./docusaurus/docs ./docs && mkdir ./docs/examples",
+        "build:armory": "npm --prefix examples/react-armory run build && cp -r ./examples/react-armory/dist ./docs/examples/armory",
+        "build:shoes": "npm --prefix examples/react-shoes run build && cp -r ./examples/react-shoes/dist ./docs/examples/shoes",
         "test": "vitest"
     },
     "repository": {

package/dist/core/__tests__/selected-items.test.d.ts

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

package/dist/core/layout/layout-interface.d.ts

@@ -1,19 +0,0 @@
-import { LayoutMixin } from "./layout";
-/**
- * Public surface for the Filters mixin
- */
-declare function readonlyLayoutInterface(mixin: LayoutMixin): {
-    variants: import("../..").LayoutVariant[];
-    activeLayout: import("../..").LayoutVariant | undefined;
-    raw: import("../..").LayoutVariant | undefined;
-    is: (identifier: string | import("../..").LayoutVariant | undefined) => boolean;
-};
-declare function layoutInterface(mixin: LayoutMixin): {
-    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;
-};
-export { readonlyLayoutInterface, layoutInterface };

package/dist/core/layout/layout.d.ts

@@ -1,21 +0,0 @@
-import { LayoutVariant } from "../../types";
-import { MixinInjectedDependencies } from "../types/internal-types";
-type InitialValues = {
-    layoutVariants: LayoutVariant[] | undefined;
-    initialLayout: string | undefined;
-};
-/**
- * A layout could be a masonry gallery, a table list, or anything you like.
- * Finder's React components will attach this mixin to the renderProps method.
- */
-declare class LayoutMixin {
-    #private;
-    variants: LayoutVariant[];
-    constructor({ layoutVariants, initialLayout }: InitialValues, mixinDeps: MixinInjectedDependencies);
-    set(identifier: string | LayoutVariant | undefined): void;
-    is(identifier: string | LayoutVariant | undefined): boolean;
-    reset(): void;
-    get activeLayout(): LayoutVariant | undefined;
-    get raw(): LayoutVariant | undefined;
-}
-export { LayoutMixin };

package/dist/core/meta/meta-interface.d.ts

@@ -1,18 +0,0 @@
-import { MetaMixin } from "./meta";
-/**
- * Public surface for the Meta mixin
- */
-declare function readonlyMetaInterface<FItem>(mixin: MetaMixin<FItem>): {
-    value: Record<string, any>;
-    get: (metaIdentifier: any) => any;
-    has: (metaIdentifier: any) => boolean;
-};
-declare function metaInterface<FItem>(mixin: MetaMixin<FItem>): {
-    set: (metaIdentifier: any, value: any) => void;
-    delete: (metaIdentifier: any) => void;
-    reset: () => void;
-    value: Record<string, any>;
-    get: (metaIdentifier: any) => any;
-    has: (metaIdentifier: any) => boolean;
-};
-export { readonlyMetaInterface, metaInterface };

package/dist/core/meta/meta.d.ts

@@ -1,16 +0,0 @@
-import { MixinInjectedDependencies } from "../types/internal-types";
-type InitialValues = {
-    initialMeta?: Record<string, any>;
-};
-declare class MetaMixin<FItem> {
-    #private;
-    meta: Record<string, any>;
-    constructor({ initialMeta }: InitialValues, deps: MixinInjectedDependencies<FItem>);
-    set(metaIdentifier: any, value: any): void;
-    get(metaIdentifier: any): any;
-    has(metaIdentifier: any): boolean;
-    delete(metaIdentifier: any): void;
-    reset(): void;
-    get value(): Record<string, any>;
-}
-export { MetaMixin };

package/dist/core/plugins/plugin-mediator.d.ts

@@ -1,14 +0,0 @@
-import { FinderInitEvent, FinderFirstUserInteractionEvent, FinderPluginFn, FinderPluginInterface, FinderTouchCallback } from "../../types";
-import { FinderCore } from "../finder-core";
-import { FinderPlugin } from "./plugin-super-class";
-export declare class PluginMediator<FItem> {
-    #private;
-    constructor(plugins: (FinderPluginFn<FinderPluginInterface> | FinderPluginInterface | FinderPlugin)[], getInstance: () => FinderCore<FItem>, touch: FinderTouchCallback);
-    get<T extends FinderPluginInterface>(identifier: string | T): T;
-    has<T extends FinderPluginInterface>(identifier: string | T): boolean;
-    /**
-     * Notify all plugins that Finder is alive
-     */
-    onInit(event: FinderInitEvent): void;
-    onFirstUserInteraction(event: FinderFirstUserInteractionEvent): void;
-}

package/dist/core/plugins/plugin-super-class.d.ts

@@ -1,8 +0,0 @@
-import { FinderPluginInterface, FinderTouchCallback } from "../../types";
-import { FinderCore } from "../finder-core";
-export declare abstract class FinderPlugin implements FinderPluginInterface {
-    abstract id: string;
-    instance: FinderCore<any> | undefined;
-    touch: FinderTouchCallback | undefined;
-    register(finder: FinderCore<any>, touch: FinderTouchCallback): void;
-}

package/dist/core/search/algorithms/unordered-characters.d.ts

@@ -1,2 +0,0 @@
-import { Haystack } from "../haystack";
-export declare function calculateUnorderedCharacterIndexes(haystack: Haystack, needle: string): number[] | undefined;

package/dist/core/selected-items/selected-items-interface.d.ts

@@ -1,22 +0,0 @@
-import { SelectedItemsMixin } from "./selected-items";
-/**
- * Public surface for the Selected Items mixin
- */
-declare function readonlySelectedItemsInterface<FItem>(mixin: SelectedItemsMixin<FItem>): {
-    items: FItem[];
-    maxSelectedItems: number | undefined;
-    isSelected: (item: FItem) => boolean;
-};
-declare function selectedItemsInterface<FItem>(mixin: SelectedItemsMixin<FItem>): {
-    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;
-};
-export { readonlySelectedItemsInterface, selectedItemsInterface };

package/dist/core/selected-items/selected-items.d.ts

@@ -1,23 +0,0 @@
-import { MixinInjectedDependencies } from "../types/internal-types";
-type InitialValues<FItem> = {
-    initialSelectedItems: FItem[] | undefined;
-    maxSelectedItems: number | undefined;
-};
-declare class SelectedItemsMixin<FItem> {
-    selectedItems: FItem[];
-    maxSelectedItems: number | undefined;
-    deps: MixinInjectedDependencies<FItem>;
-    constructor({ initialSelectedItems, maxSelectedItems }: InitialValues<FItem>, handlers: MixinInjectedDependencies<FItem>);
-    setMaxSelectedItems(value?: number): void;
-    set(items: FItem[]): void;
-    select(item: FItem): void;
-    /**
-     * Select a single item and clear any other selected items.
-     */
-    selectOnly(item: FItem): void;
-    toggle(item: FItem): void;
-    toggleOnly(item: FItem): void;
-    delete(item: FItem): void;
-    reset(): void;
-}
-export { SelectedItemsMixin };

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

@@ -1,15 +0,0 @@
-/**
- * These internal types are not intended for public consumption.
- */
-import { FinderRule, FinderTouchCallback, MetaInterface } from "../../types";
-import { DebounceCallbackRegistry } from "../debounce-callback-registry/debounce-callback-registry";
-export interface MixinInjectedDependencies<FItem = any> {
-    isLoading: () => boolean;
-    isDisabled: () => boolean;
-    getRules: () => FinderRule[];
-    touch: FinderTouchCallback;
-    getMeta: () => MetaInterface;
-    getItems: () => FItem[];
-    debouncer: DebounceCallbackRegistry;
-}
-export type EventCallback = (payload?: any) => void;

package/dist/core/utils/string-compare-utils.d.ts

@@ -1,13 +0,0 @@
-/**
- * Case-insensitive sequential string comparison with line breaks and white spaces removed.
- * If the method receive an optional aliases array, each of those aliases will be compared as well.
- */
-export declare function finderStringCompare(haystack: string, needle: string, aliases?: string[] | null): boolean;
-/**
- * Compare if the same characters are all represented in a string.
- */
-export declare function finderCharacterCompare(haystack: string, needle: string, aliases?: string[] | null): boolean;
-/**
- * Compare if the same characters are represented sequentially in a string.
- */
-export declare function finderSequentialCharacterCompare(haystack: string, needle: string, aliases?: string[] | null): boolean;

package/dist/react/components/finder-empty.d.ts

@@ -1,6 +0,0 @@
-import { FinderBaseRenderProp } from "../types/react-types";
-interface FinderEmptyProps {
-    children: FinderBaseRenderProp;
-}
-declare function FinderEmpty({ children: renderProp }: FinderEmptyProps): Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null;
-export { FinderEmpty };

package/dist/react/components/finder-groups.d.ts

@@ -1,7 +0,0 @@
-import { ElementType } from "react";
-import { FinderGroupsComponentProps } from "../types/react-types";
-interface FinderGroupsProps<FItem = any> {
-    children: ElementType<FinderGroupsComponentProps<FItem>>;
-}
-declare function FinderGroups<FItem>({ children: renderProp }: FinderGroupsProps<FItem>): import("react/jsx-runtime").JSX.Element | null;
-export { FinderGroups };

package/dist/react/components/finder-items.d.ts

@@ -1,7 +0,0 @@
-import { ElementType } from "react";
-import { FinderItemsComponentProps } from "../types/react-types";
-interface FinderItemsProps<FItem = any> {
-    children: ElementType<FinderItemsComponentProps<FItem>>;
-}
-declare function FinderItems<FItem>({ children: renderProp }: FinderItemsProps<FItem>): import("react/jsx-runtime").JSX.Element | null;
-export { FinderItems };

package/dist/react/components/finder-loading.d.ts

@@ -1,6 +0,0 @@
-import { FinderBaseRenderProp } from "../types/react-types";
-interface FinderLoadingProps {
-    children: FinderBaseRenderProp;
-}
-declare function FinderLoading({ children: renderProp }: FinderLoadingProps): Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null;
-export { FinderLoading };

package/dist/react/components/finder-no-matches.d.ts

@@ -1,6 +0,0 @@
-import { FinderBaseRenderProp } from "../types/react-types";
-interface FinderNoMatchesProps {
-    children: FinderBaseRenderProp;
-}
-declare function FinderNoMatches({ children: renderProp }: FinderNoMatchesProps): Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null;
-export { FinderNoMatches };

package/dist/react/hooks/use-finder-context.d.ts

@@ -1,2 +0,0 @@
-declare function useFinderContext(): import("../../core/finder-core").FinderCore<any>;
-export { useFinderContext };

package/dist/react/providers/finder-context.d.ts

@@ -1,3 +0,0 @@
-import { FinderCore } from "../../core/finder-core";
-declare const FinderContext: import("react").Context<[FinderCore<any>, number | undefined] | null>;
-export { FinderContext };