@nu-art/search 0.400.7

package/_core/SearchAddOn.d.ts

@@ -0,0 +1,27 @@
+import { DBPointer } from '@nu-art/ts-common';
+export type SearchResult = DBPointer & {
+    filterResults: {
+        [k: string]: {
+            value: any;
+            score?: number;
+        };
+    };
+};
+export type SearchAddOnDef<Key extends string, //The addon key
+ValueType extends any, //The type of the value held in the filter dictionary
+MethodName extends string, //The name of the method that the search item needs to implement
+ItemValueType extends any> = {
+    key: Key;
+    valueType: ValueType;
+    methodName: MethodName;
+    itemValueType: ItemValueType;
+};
+export type SearchAddOn<Def extends SearchAddOnDef<any, any, any, any>> = {
+    key: Def['key'];
+    methodName: Def['methodName'];
+    resultFilter: (value: NonNullable<Def['valueType']>, item: SearchResult) => {
+        pass: boolean;
+        score?: number;
+    };
+    isActive: (param: Def['valueType']) => boolean;
+};

package/_core/SearchAddOn.js

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

package/_core/SearchContext.d.ts

@@ -0,0 +1,58 @@
+import { Logger } from '@nu-art/ts-common';
+import { SearchAddOn, SearchAddOnDef, SearchResult } from './SearchAddOn.js';
+import { SearchItem } from './SearchItem.js';
+import { SearchSorter } from './SearchSorter.js';
+export interface SearchAddOnRenderer {
+    __onSearchFilterChanged: VoidFunction;
+    readonly addOn: SearchAddOn<any>;
+}
+export interface SearchResultsRenderer {
+    __onSearchResultsChanged: VoidFunction;
+}
+export declare class SearchContext extends Logger {
+    private searchItems;
+    private activeSearchItems;
+    private addOns;
+    private activeAddOns;
+    private sorters;
+    private minimumRequiredActiveAddons;
+    private readonly searchDebouncer;
+    private readonly filterDictionary;
+    private readonly _filterChangeListeners;
+    private searchResults?;
+    private searchTime?;
+    private readonly _searchResultChangeListeners;
+    constructor(key: string);
+    setSearchItems: (items: SearchItem<any, any>[]) => this;
+    setAddOns: (addOns: SearchAddOn<any>[]) => this;
+    setSorters: (sorters: SearchSorter<any>[]) => this;
+    setMinimumRequiredActiveAddOns: (num: number) => this;
+    private setActiveAddOns;
+    private setActiveSearchItems;
+    private getInitialSearchResults;
+    private search;
+    getActiveSearchItems: () => Readonly<{
+        module: import("@nu-art/thunderstorm-frontend").ModuleFE_BaseDB<any, import("@nu-art/thunderstorm-frontend/core/db-api-gen/db-def").DBApiFEConfig<any>>;
+        entityLabel: string;
+        addOnMethods: Readonly<{
+            [x: string]: (result: SearchResult) => unknown;
+        }>;
+        compatibleAddOnKeys: readonly PropertyKey[];
+        resultRenderer: (result: SearchResult, style?: import("react").CSSProperties) => import("react").ReactNode;
+        labelResolver: (result: SearchResult) => string;
+    }>[];
+    getSearchResults: () => SearchResult[] | undefined;
+    getSearchTime: () => number | undefined;
+    filter: {
+        set: <AddOn extends SearchAddOnDef<string, any, any, any>>(key: AddOn["key"], value: AddOn["valueType"]) => void;
+        get: <AddOn extends SearchAddOnDef<string, any, any, any>>(key: AddOn["key"]) => AddOn["valueType"] | undefined;
+    };
+    filterChangeListeners: {
+        register: (renderer: SearchAddOnRenderer) => void;
+        unregister: (renderer: SearchAddOnRenderer) => void;
+    };
+    searchResultChangeListeners: {
+        register: (renderer: SearchResultsRenderer) => void;
+        unregister: (renderer: SearchResultsRenderer) => void;
+    };
+}

package/_core/SearchContext.js

@@ -0,0 +1,147 @@
+import { arrayIncludesAll, BadImplementationException, Debounce, Logger, removeItemFromArray } from '@nu-art/ts-common';
+export class SearchContext extends Logger {
+    searchItems;
+    activeSearchItems;
+    addOns;
+    activeAddOns;
+    sorters;
+    minimumRequiredActiveAddons = 0;
+    searchDebouncer = new Debounce(() => this.search(), 200, 500);
+    filterDictionary = {};
+    _filterChangeListeners = [];
+    searchResults;
+    searchTime;
+    _searchResultChangeListeners = [];
+    constructor(key) {
+        super(`SearchContext-${key}`);
+        this.searchItems = [];
+        this.activeSearchItems = [];
+        this.addOns = [];
+        this.activeAddOns = [];
+        this.sorters = [];
+    }
+    //######################### Factory Logic #########################
+    setSearchItems = (items) => {
+        this.searchItems = items;
+        this.setActiveSearchItems();
+        this.logInfo('Set Search Items', this.searchItems);
+        return this;
+    };
+    setAddOns = (addOns) => {
+        this.addOns = addOns;
+        this.setActiveAddOns();
+        this.setActiveSearchItems();
+        return this;
+    };
+    setSorters = (sorters) => {
+        this.sorters = sorters;
+        return this;
+    };
+    setMinimumRequiredActiveAddOns = (num) => {
+        this.minimumRequiredActiveAddons = num;
+        return this;
+    };
+    //######################### Internal Logic #########################
+    setActiveAddOns = () => {
+        this.activeAddOns = this.addOns.filter(addOn => {
+            const currentValue = this.filterDictionary[addOn.key];
+            return addOn.isActive(currentValue);
+        });
+    };
+    setActiveSearchItems = () => {
+        const activeAddOnKeys = this.activeAddOns.map(addOn => addOn.key);
+        if (!activeAddOnKeys.length)
+            return this.activeSearchItems = [...this.searchItems];
+        this.activeSearchItems = this.searchItems.filter(searchItem => arrayIncludesAll(searchItem.compatibleAddOnKeys, activeAddOnKeys));
+    };
+    getInitialSearchResults = () => {
+        const results = [];
+        this.activeSearchItems.forEach(searchItem => {
+            const pointers = searchItem.module.cache.all().map(i => ({ dbKey: searchItem.module.dbDef.dbKey, id: i._id, filterResults: {} }));
+            results.push(...pointers);
+        });
+        return results;
+    };
+    search = () => {
+        if (this.activeAddOns.length < this.minimumRequiredActiveAddons) {
+            if (this.addOns.length) {
+                delete this.searchResults;
+                delete this.searchTime;
+                this._searchResultChangeListeners.forEach(listener => listener.__onSearchResultsChanged());
+            }
+            return;
+        }
+        const startTime = Date.now();
+        let searchResults = this.getInitialSearchResults();
+        //Map active search item to dbKeys for O(1) access
+        const searchItemMap = this.activeSearchItems.reduce((map, item) => {
+            map[item.module.dbDef.dbKey] = item;
+            return map;
+        }, {});
+        //Cycle filter the results by active add-ons
+        this.activeAddOns.forEach(addOn => {
+            const filterValue = this.filterDictionary[addOn.key];
+            searchResults = searchResults.filter(result => {
+                const searchItem = searchItemMap[result.dbKey];
+                result.filterResults[addOn.key] = { value: searchItem.addOnMethods[addOn.methodName](result) };
+                const filterResult = addOn.resultFilter(filterValue, result);
+                result.filterResults[addOn.key].score = filterResult.score;
+                return filterResult.pass;
+            });
+        });
+        //Sort results
+        this.sorters.forEach(sorter => {
+            const addOn = this.activeAddOns.find(addOn => addOn.key === sorter.key);
+            if (!addOn) //No connected active addon was found, do not run sorter
+                return;
+            sorter.sortFunction(searchResults);
+        });
+        this.searchResults = searchResults;
+        this.searchTime = Date.now() - startTime;
+        this._searchResultChangeListeners.forEach(listener => listener.__onSearchResultsChanged());
+    };
+    //######################### Public Logic #########################
+    getActiveSearchItems = () => [...this.activeSearchItems];
+    getSearchResults = () => this.searchResults;
+    getSearchTime = () => this.searchTime;
+    filter = {
+        set: (key, value) => {
+            this.filterDictionary[key] = value;
+            //Re-calculate active addons and search items
+            this.setActiveAddOns();
+            this.setActiveSearchItems();
+            //Notify all listeners that filters have changed
+            this._filterChangeListeners.forEach(listener => listener.__onSearchFilterChanged());
+            //Trigger search
+            this.searchDebouncer.trigger();
+        },
+        get: (key) => {
+            return this.filterDictionary[key];
+        },
+    };
+    filterChangeListeners = {
+        register: (renderer) => {
+            if (this._filterChangeListeners.includes(renderer))
+                return;
+            const addOn = this.addOns.find(addOn => addOn.key === renderer.addOn.key);
+            if (!addOn) {
+                this.logError(renderer, this.addOns);
+                throw new BadImplementationException('Trying to register a listener that is not connected to an addon');
+            }
+            this._filterChangeListeners.push(renderer);
+        },
+        unregister: (renderer) => {
+            removeItemFromArray(this._filterChangeListeners, renderer);
+        }
+    };
+    searchResultChangeListeners = {
+        register: (renderer) => {
+            if (this._searchResultChangeListeners.includes(renderer))
+                return;
+            this._searchResultChangeListeners.push(renderer);
+        },
+        unregister: (renderer) => {
+            removeItemFromArray(this._searchResultChangeListeners, renderer);
+        }
+    };
+}

package/_core/SearchItem.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties, ReactNode } from 'react';
+import { DBProto } from '@nu-art/ts-common';
+import { SearchAddOnDef, SearchResult } from './SearchAddOn.js';
+import { ModuleFE_BaseDB } from '@nu-art/thunderstorm-frontend';
+type AddOnTuple = readonly SearchAddOnDef<any, any, any, any>[];
+type SearchAddOnsMethodExtractor<A extends AddOnTuple> = {
+    [M in A[number]['methodName']]: Extract<A[number], {
+        methodName: M;
+    }> extends {
+        itemValueType: infer IP;
+    } ? (result: SearchResult) => IP : never;
+};
+type SearchAddOnsKeyExtractor<A extends AddOnTuple> = {
+    readonly [K in keyof A]: A[K] extends {
+        key: infer Key extends PropertyKey;
+    } ? Key : never;
+};
+export type SearchItem<Proto extends DBProto<any>, A extends AddOnTuple> = Readonly<{
+    module: ModuleFE_BaseDB<Proto>;
+    entityLabel: string;
+    addOnMethods: Readonly<SearchAddOnsMethodExtractor<A>>;
+    compatibleAddOnKeys: Readonly<SearchAddOnsKeyExtractor<A>>;
+    resultRenderer: (result: SearchResult, style?: CSSProperties) => ReactNode;
+    labelResolver: (result: SearchResult) => string;
+}>;
+export {};

package/_core/SearchItem.js

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

package/_core/SearchSorter.d.ts

@@ -0,0 +1,5 @@
+import { SearchAddOnDef, SearchResult } from './SearchAddOn.js';
+export type SearchSorter<AddOnDef extends SearchAddOnDef<string, any, string, any>> = {
+    key: AddOnDef['key'];
+    sortFunction: (results: SearchResult[]) => void;
+};

package/_core/SearchSorter.js

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

package/_core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './SearchAddOn.js';
+export * from './SearchItem.js';
+export * from './SearchContext.js';

package/_core/index.js

@@ -0,0 +1,3 @@
+export * from './SearchAddOn.js';
+export * from './SearchItem.js';
+export * from './SearchContext.js';

package/_ui/add-ons/entity-filter/Component_AddOn_EntityFilter.d.ts

@@ -0,0 +1,22 @@
+import { Component_SearchAddOn } from '../../components/Component_SearchAddOn.js';
+import { AddOnDef_EntityFilter } from './types.js';
+import { InferProps, InferState } from '@nu-art/thunderstorm-frontend';
+import './Component_AddOn_EntityFilter.scss';
+import { SearchAddOn, SearchItem } from '../../../_core/index.js';
+type Props = {
+    label?: string;
+};
+type State = {
+    label: string;
+    activeSearchItems: SearchItem<any, any>[];
+};
+export declare class Component_AddOn_EntityFilter extends Component_SearchAddOn<AddOnDef_EntityFilter, Props, State> {
+    addOn: SearchAddOn<AddOnDef_EntityFilter>;
+    protected deriveStateFromProps(nextProps: InferProps<this>, state: InferState<this>): InferState<this>;
+    private onItemSelected;
+    private onItemRemoved;
+    render(): import("react/jsx-runtime").JSX.Element | undefined;
+    private render_SelectedItem;
+    private render_ItemSelector;
+}
+export {};

package/_ui/add-ons/entity-filter/Component_AddOn_EntityFilter.js

@@ -0,0 +1,41 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Component_SearchAddOn } from '../../components/Component_SearchAddOn.js';
+import { AddOn_EntityFilter } from './types.js';
+import { LL_H_C, SimpleListAdapter, TS_DropDown, TS_PropRenderer } from '@nu-art/thunderstorm-frontend';
+import { TS_Icons } from '@nu-art/ts-styles';
+import './Component_AddOn_EntityFilter.scss';
+export class Component_AddOn_EntityFilter extends Component_SearchAddOn {
+    addOn = AddOn_EntityFilter;
+    // ######################### Life Cycle #########################
+    deriveStateFromProps(nextProps, state) {
+        state.label = nextProps.label ?? 'By Entity';
+        state.activeSearchItems = nextProps.context.getActiveSearchItems();
+        return state;
+    }
+    // ######################### Logic #########################
+    onItemSelected = (searchItem) => {
+        const items = this.state.value ? [...this.state.value] : [];
+        items.push(searchItem.module.dbDef.dbKey);
+        this.setValue(items);
+    };
+    onItemRemoved = (searchItem) => {
+        const items = (this.state.value ?? []).filter(item => item !== searchItem.module.dbDef.dbKey);
+        this.setValue(items);
+    };
+    // ######################### Render #########################
+    render() {
+        if (!this.state.activeSearchItems)
+            return;
+        return _jsx(TS_PropRenderer.Vertical, { label: this.state.label, className: 'search-add-on__entity-filter', children: _jsxs(LL_H_C, { className: 'search-add-on__entity-filter__item-list', children: [this.state.value?.map(this.render_SelectedItem), this.render_ItemSelector()] }) });
+    }
+    render_SelectedItem = (itemKey) => {
+        const searchItem = this.state.activeSearchItems.find(item => item.module.dbDef.dbKey === itemKey);
+        if (!searchItem)
+            return void this.logWarning(`Could not find a search item for key ${itemKey}`);
+        return _jsxs(LL_H_C, { className: 'search-add-on__entity-filter__selected-item', children: [searchItem.entityLabel, _jsx(TS_Icons.x.component, { onClick: () => this.onItemRemoved(searchItem) })] }, searchItem.module.dbDef.dbKey);
+    };
+    render_ItemSelector = () => {
+        const adapter = SimpleListAdapter(this.state.activeSearchItems, item => _jsx(_Fragment, { children: item.item.entityLabel }));
+        return _jsx(TS_DropDown, { adapter: adapter, selected: undefined, onSelected: this.onItemSelected, placeholder: 'Select an entity', queryFilter: item => !this.state.value?.includes(item.module.dbDef.dbKey) });
+    };
+}

package/_ui/add-ons/entity-filter/Component_AddOn_EntityFilter.scss

@@ -0,0 +1,14 @@
+.search-add-on__entity-filter {
+  padding: 16px;
+  flex-shrink: 0;
+
+  .search-add-on__entity-filter__item-list {
+    width: 100%;
+    flex-wrap: wrap;
+    gap: 8px;
+
+    .ts-dropdown {
+      max-width: 150px;
+    }
+  }
+}

package/_ui/add-ons/entity-filter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './Component_AddOn_EntityFilter.js';

package/_ui/add-ons/entity-filter/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './Component_AddOn_EntityFilter.js';

package/_ui/add-ons/entity-filter/types.d.ts

@@ -0,0 +1,3 @@
+import { SearchAddOn, SearchAddOnDef } from '../../../_core/index.js';
+export type AddOnDef_EntityFilter = SearchAddOnDef<'entity', string[] | undefined, 'getEntityKey', string>;
+export declare const AddOn_EntityFilter: SearchAddOn<AddOnDef_EntityFilter>;

package/_ui/add-ons/entity-filter/types.js

@@ -0,0 +1,8 @@
+export const AddOn_EntityFilter = {
+    key: 'entity',
+    methodName: 'getEntityKey',
+    resultFilter: (entities, result) => {
+        return { pass: entities.includes(result.filterResults['entity'].value) };
+    },
+    isActive: (entities) => !!entities?.length,
+};

package/_ui/add-ons/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity-filter/index.js';
+export * from './search-term/index.js';
+export * from './search-terms/index.js';

package/_ui/add-ons/index.js

@@ -0,0 +1,3 @@
+export * from './entity-filter/index.js';
+export * from './search-term/index.js';
+export * from './search-terms/index.js';

package/_ui/add-ons/search-term/Component_AddOn_SearchTerm.d.ts

@@ -0,0 +1,17 @@
+import { SearchAddOn } from '../../../_core/index.js';
+import { Component_SearchAddOn } from '../../components/Component_SearchAddOn.js';
+import { AddOnDef_SearchTerm } from './types.js';
+import './Component_AddOn_SearchTerm.scss';
+import { InferProps, InferState } from '@nu-art/thunderstorm-frontend';
+type Props = {
+    placeholder?: string;
+};
+type State = {
+    placeholder?: string;
+};
+export declare class Component_AddOn_SearchTerm extends Component_SearchAddOn<AddOnDef_SearchTerm, Props, State> {
+    protected deriveStateFromProps(nextProps: InferProps<this>, state: InferState<this>): InferState<this>;
+    addOn: SearchAddOn<AddOnDef_SearchTerm>;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/_ui/add-ons/search-term/Component_AddOn_SearchTerm.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LL_H_C, TS_Input } from '@nu-art/thunderstorm-frontend';
+import { Component_SearchAddOn } from '../../components/Component_SearchAddOn.js';
+import { AddOn_SearchTerm } from './types.js';
+import './Component_AddOn_SearchTerm.scss';
+import { TS_Icons } from '@nu-art/ts-styles';
+export class Component_AddOn_SearchTerm extends Component_SearchAddOn {
+    deriveStateFromProps(nextProps, state) {
+        state.placeholder = nextProps.placeholder;
+        return state;
+    }
+    addOn = AddOn_SearchTerm;
+    render() {
+        return _jsxs(LL_H_C, { className: 'search-add-on__search-term', children: [_jsx(TS_Input, { type: 'text', value: this.state.value, placeholder: this.state.placeholder, onChange: val => this.setValue(val.trimStart()) }), _jsx(TS_Icons.Search.component, {})] });
+    }
+}

package/_ui/add-ons/search-term/Component_AddOn_SearchTerm.scss

@@ -0,0 +1,21 @@
+.search-add-on__search-term {
+  width: 100%;
+  min-width: 300px;
+  height: 28px;
+  gap: 16px;
+  background: #fff;
+  border-radius: 10px;
+  padding: 0 16px;
+
+  .icon--wrapper {
+    flex-shrink: 0;
+  }
+
+  .ts-input {
+    width: 0;
+    flex: 1;
+    border: none;
+    max-width: unset;
+    outline: none;
+  }
+}

package/_ui/add-ons/search-term/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './Component_AddOn_SearchTerm.js';

package/_ui/add-ons/search-term/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './Component_AddOn_SearchTerm.js';

package/_ui/add-ons/search-term/types.d.ts

@@ -0,0 +1,3 @@
+import { SearchAddOn, SearchAddOnDef } from '../../../_core/index.js';
+export type AddOnDef_SearchTerm = SearchAddOnDef<'searchTerm', string | undefined, 'getSearchTerm', string>;
+export declare const AddOn_SearchTerm: SearchAddOn<AddOnDef_SearchTerm>;

package/_ui/add-ons/search-term/types.js

@@ -0,0 +1,21 @@
+var SearchTermSortScore;
+(function (SearchTermSortScore) {
+    SearchTermSortScore[SearchTermSortScore["ExactMatch"] = 0] = "ExactMatch";
+    SearchTermSortScore[SearchTermSortScore["StartsWith"] = 1] = "StartsWith";
+    SearchTermSortScore[SearchTermSortScore["Includes"] = 2] = "Includes";
+})(SearchTermSortScore || (SearchTermSortScore = {}));
+export const AddOn_SearchTerm = {
+    key: 'searchTerm',
+    methodName: 'getSearchTerm',
+    resultFilter: (value, result) => {
+        const itemValue = result.filterResults[AddOn_SearchTerm.key].value;
+        if (itemValue === value)
+            return { pass: true, score: SearchTermSortScore.ExactMatch };
+        if (itemValue.startsWith(value))
+            return { pass: true, score: SearchTermSortScore.StartsWith };
+        if (itemValue.includes(value))
+            return { pass: true, score: SearchTermSortScore.Includes };
+        return { pass: false };
+    },
+    isActive: (param) => !!param && param.length >= 3,
+};

package/_ui/add-ons/search-terms/Component_AddOn_SearchTerms.d.ts

@@ -0,0 +1,17 @@
+import { SearchAddOn } from '../../../_core/index.js';
+import { Component_SearchAddOn } from '../../components/Component_SearchAddOn.js';
+import { AddOnDef_SearchTerms } from './types.js';
+import './Component_AddOn_SearchTerms.scss';
+import { InferProps, InferState } from '@nu-art/thunderstorm-frontend';
+type Props = {
+    placeholder?: string;
+};
+type State = {
+    placeholder?: string;
+};
+export declare class Component_AddOn_SearchTerms extends Component_SearchAddOn<AddOnDef_SearchTerms, Props, State> {
+    protected deriveStateFromProps(nextProps: InferProps<this>, state: InferState<this>): InferState<this>;
+    addOn: SearchAddOn<AddOnDef_SearchTerms>;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/_ui/add-ons/search-terms/Component_AddOn_SearchTerms.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LL_H_C, TS_Input } from '@nu-art/thunderstorm-frontend';
+import { Component_SearchAddOn } from '../../components/Component_SearchAddOn.js';
+import { AddOn_SearchTerms } from './types.js';
+import './Component_AddOn_SearchTerms.scss';
+import { TS_Icons } from '@nu-art/ts-styles';
+export class Component_AddOn_SearchTerms extends Component_SearchAddOn {
+    deriveStateFromProps(nextProps, state) {
+        state.placeholder = nextProps.placeholder;
+        return state;
+    }
+    addOn = AddOn_SearchTerms;
+    render() {
+        return _jsxs(LL_H_C, { className: 'search-add-on__search-terms', children: [_jsx(TS_Input, { type: 'text', value: this.state.value, placeholder: this.state.placeholder, onChange: val => this.setValue(val.trimStart()) }), _jsx(TS_Icons.Search.component, {})] });
+    }
+}

package/_ui/add-ons/search-terms/Component_AddOn_SearchTerms.scss

@@ -0,0 +1,21 @@
+.search-add-on__search-terms {
+  width: 100%;
+  min-width: 300px;
+  height: 28px;
+  gap: 16px;
+  background: #fff;
+  border-radius: 10px;
+  padding: 0 16px;
+
+  .icon--wrapper {
+    flex-shrink: 0;
+  }
+
+  .ts-input {
+    width: 0;
+    flex: 1;
+    border: none;
+    max-width: unset;
+    outline: none;
+  }
+}

package/_ui/add-ons/search-terms/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './Component_AddOn_SearchTerms.js';

package/_ui/add-ons/search-terms/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './Component_AddOn_SearchTerms.js';

package/_ui/add-ons/search-terms/types.d.ts

@@ -0,0 +1,3 @@
+import { SearchAddOn, SearchAddOnDef } from '../../../_core/index.js';
+export type AddOnDef_SearchTerms = SearchAddOnDef<'searchTerms', string | undefined, 'getSearchTerms', string[]>;
+export declare const AddOn_SearchTerms: SearchAddOn<AddOnDef_SearchTerms>;

package/_ui/add-ons/search-terms/types.js

@@ -0,0 +1,31 @@
+var BaseScore;
+(function (BaseScore) {
+    BaseScore[BaseScore["ExactMatch"] = 1] = "ExactMatch";
+    BaseScore[BaseScore["StartsWith"] = 2] = "StartsWith";
+    BaseScore[BaseScore["Includes"] = 3] = "Includes";
+})(BaseScore || (BaseScore = {}));
+const calcScore = (base, index) => {
+    return base - (1 / Math.pow(2, index));
+};
+export const AddOn_SearchTerms = {
+    key: 'searchTerms',
+    methodName: 'getSearchTerms',
+    isActive: (param) => !!param && param.length >= 3,
+    resultFilter: (value, result) => {
+        const terms = result.filterResults[AddOn_SearchTerms.key].value;
+        let index;
+        //Find exact match
+        index = terms.findIndex(term => term === value);
+        if (index !== -1)
+            return { pass: true, score: calcScore(BaseScore.ExactMatch, index) };
+        //Find StatsWith
+        index = terms.findIndex(term => term.startsWith(value));
+        if (index !== -1)
+            return { pass: true, score: calcScore(BaseScore.StartsWith, index) };
+        //Find Includes
+        index = terms.findIndex(term => term.includes(value));
+        if (index !== -1)
+            return { pass: true, score: calcScore(BaseScore.Includes, index) };
+        return { pass: false };
+    }
+};

package/_ui/components/Component_SearchAddOn.d.ts

@@ -0,0 +1,16 @@
+import { ComponentSync } from '@nu-art/thunderstorm-frontend';
+import { SearchAddOn, SearchAddOnDef, SearchAddOnRenderer, SearchContext } from '../../_core/index.js';
+type Props = {
+    context: SearchContext;
+};
+type State<AddOnDef extends SearchAddOnDef<string, any, any, any>> = {
+    value?: AddOnDef['valueType'];
+};
+export declare abstract class Component_SearchAddOn<AddOnDef extends SearchAddOnDef<string, any, any, any>, _Props extends {} = {}, _State extends {} = {}, P extends _Props & Props = _Props & Props, S extends _State & State<AddOnDef> = _State & State<AddOnDef>> extends ComponentSync<P, S> implements SearchAddOnRenderer {
+    abstract readonly addOn: SearchAddOn<AddOnDef>;
+    __onSearchFilterChanged(): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    protected setValue: (val?: AddOnDef["valueType"]) => void;
+}
+export {};

package/_ui/components/Component_SearchAddOn.js

@@ -0,0 +1,20 @@
+import { ComponentSync } from '@nu-art/thunderstorm-frontend';
+import { compare } from '@nu-art/ts-common';
+export class Component_SearchAddOn extends ComponentSync {
+    //######################### Life Cycle #########################
+    __onSearchFilterChanged() {
+        const nextValue = this.props.context.filter.get(this.addOn.key);
+        if (!compare(this.state.value, nextValue))
+            this.setState({ value: nextValue });
+    }
+    componentDidMount() {
+        this.props.context.filterChangeListeners.register(this);
+    }
+    componentWillUnmount() {
+        this.props.context.filterChangeListeners.unregister(this);
+    }
+    //######################### Logic #########################
+    setValue = (val) => {
+        this.props.context.filter.set(this.addOn.key, val);
+    };
+}

package/_ui/components/Component_SearchMeta/Component_SearchMeta.d.ts

@@ -0,0 +1,16 @@
+import { ComponentSync } from '@nu-art/thunderstorm-frontend';
+import './Component_SearchMeta.scss';
+import { SearchContext, SearchResultsRenderer } from '../../../_core/SearchContext.js';
+type Props = {
+    context: SearchContext;
+};
+export declare class Component_SearchMeta extends ComponentSync<Props> implements SearchResultsRenderer {
+    __onSearchResultsChanged: () => void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private printResults;
+    private exportResults;
+    render(): import("react/jsx-runtime").JSX.Element | undefined;
+    private renderTime;
+}
+export {};

package/_ui/components/Component_SearchMeta/Component_SearchMeta.js

@@ -0,0 +1,66 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { ComponentSync, LL_H_C, ModuleFE_Thunderstorm, stopPropagation } from '@nu-art/thunderstorm-frontend';
+import './Component_SearchMeta.scss';
+import { filterInstances, formatTimestamp } from '@nu-art/ts-common';
+import { ModuleFE_CSVParser } from '@nu-art/thunderstorm-frontend/modules/ModuleFE_CSVParser';
+export class Component_SearchMeta extends ComponentSync {
+    //######################### Life Cycle #########################
+    __onSearchResultsChanged = () => {
+        this.forceUpdate();
+    };
+    componentDidMount() {
+        this.props.context.searchResultChangeListeners.register(this);
+    }
+    componentWillUnmount() {
+        this.props.context.searchResultChangeListeners.unregister(this);
+    }
+    //######################### Logic #########################
+    printResults = (e) => {
+        if (!e.metaKey)
+            return;
+        stopPropagation(e);
+        this.logInfo('SearchResults', this.props.context.getSearchResults());
+    };
+    exportResults = (e) => {
+        const results = this.props.context.getSearchResults();
+        if (!results?.length)
+            return;
+        stopPropagation(e);
+        const searchItemMap = this.props.context.getActiveSearchItems().reduce((map, searchItem) => {
+            map[searchItem.module.dbDef.dbKey] = searchItem;
+            return map;
+        }, {});
+        //Map results csv ready objects
+        const objects = filterInstances(results.map(result => {
+            const searchItem = searchItemMap[result.dbKey];
+            if (!searchItem)
+                return;
+            return {
+                collection: result.dbKey,
+                id: result.id,
+                label: searchItem.labelResolver(result),
+            };
+        }));
+        const str = ModuleFE_CSVParser.toString(objects);
+        const fileName = `Search Results - [${formatTimestamp('DD/MM/YYYY-HH:mm:ss')}]`;
+        ModuleFE_Thunderstorm.downloadFile({
+            fileName,
+            content: str,
+            mimeType: 'text/csv',
+        });
+    };
+    //######################### Render #########################
+    render() {
+        const searchResults = this.props.context.getSearchResults();
+        if (!searchResults?.length)
+            return;
+        return _jsxs(LL_H_C, { className: 'c__search-meta', onClick: this.printResults, children: [_jsxs("div", { className: 'c__search-meta__results', onClick: this.exportResults, children: [searchResults.length, " Results"] }), this.renderTime()] });
+    }
+    renderTime = () => {
+        const searchTime = this.props.context.getSearchTime();
+        if (!searchTime)
+            return;
+        const str = searchTime >= 1000 ? `${searchTime / 1000}s` : `${searchTime}ms`;
+        return _jsx("div", { className: 'c__search-meta__time', children: str });
+    };
+}

package/_ui/components/Component_SearchMeta/Component_SearchMeta.scss

@@ -0,0 +1,17 @@
+@use '@nu-art/ts-styles' as S;
+
+.c__search-meta {
+  width: 100%;
+  height: 28px;
+  justify-content: space-between;
+
+  .c__search-meta__time {
+    color: inherit;
+    font: inherit;
+  }
+
+  .c__search-meta__results {
+    font: inherit;
+    @include S.mouse-interactive-text(inherit, S.dark-blue(4), S.dark-blue(3));
+  }
+}

package/_ui/components/Component_SearchMeta/index.d.ts

@@ -0,0 +1 @@
+export * from './Component_SearchMeta.js';

package/_ui/components/Component_SearchMeta/index.js

@@ -0,0 +1 @@
+export * from './Component_SearchMeta.js';

package/_ui/components/Component_SearchResults/Component_SearchResults.d.ts

@@ -0,0 +1,22 @@
+import { ComponentSync } from '@nu-art/thunderstorm-frontend';
+import { SearchContext, SearchResult, SearchResultsRenderer } from '../../../_core/index.js';
+import './Component_SearchResults.scss';
+type Props = {
+    context: SearchContext;
+    itemHeight: number;
+    maxItemsOnScreen: number;
+};
+type State = {
+    searchResults?: SearchResult[];
+    maxHeight: number;
+};
+export declare class Component_SearchResults extends ComponentSync<Props, State> implements SearchResultsRenderer {
+    protected deriveStateFromProps(nextProps: Props, state: State): State;
+    __onSearchResultsChanged: () => void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private getList;
+    render(): import("react/jsx-runtime").JSX.Element;
+    private render_NoResults;
+}
+export {};

package/_ui/components/Component_SearchResults/Component_SearchResults.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ComponentSync, LL_V_L, VirtualizedList } from '@nu-art/thunderstorm-frontend';
+import './Component_SearchResults.scss';
+import { filterInstances } from '@nu-art/ts-common';
+export class Component_SearchResults extends ComponentSync {
+    //######################### Life Cycle #########################
+    deriveStateFromProps(nextProps, state) {
+        state.maxHeight = nextProps.maxItemsOnScreen * nextProps.itemHeight;
+        return state;
+    }
+    __onSearchResultsChanged = () => {
+        this.setState({ searchResults: this.props.context.getSearchResults() });
+    };
+    componentDidMount() {
+        this.props.context.searchResultChangeListeners.register(this);
+    }
+    componentWillUnmount() {
+        this.props.context.searchResultChangeListeners.unregister(this);
+    }
+    //######################### Render #########################
+    getList = () => {
+        if (!this.state.searchResults?.length)
+            return [];
+        const activeSearchItemMap = this.props.context.getActiveSearchItems().reduce((map, item) => {
+            map[item.module.dbDef.dbKey] = item;
+            return map;
+        }, {});
+        return filterInstances(this.state.searchResults.map(result => {
+            const item = activeSearchItemMap[result.dbKey];
+            if (!item)
+                return;
+            return (style) => item.resultRenderer(result, style);
+        }));
+    };
+    //######################### Render #########################
+    render() {
+        if (!this.state.searchResults?.length)
+            return this.render_NoResults();
+        const list = this.getList();
+        const height = Math.min(list.length * this.props.itemHeight, this.state.maxHeight);
+        return _jsx(VirtualizedList, { className: 'c__search-results', width: 0, height: height, itemHeight: this.props.itemHeight, listToRender: list, omitWrapper: true });
+    }
+    render_NoResults = () => {
+        return _jsx(LL_V_L, { className: 'c__search-results no-results', children: "No results to show" });
+    };
+}

package/_ui/components/Component_SearchResults/Component_SearchResults.scss

@@ -0,0 +1,10 @@
+.c__search-results {
+  width: 100% !important;
+
+  &.no-results {
+    font: {
+      size: 24px;
+      weight: 600;
+    }
+  }
+}

package/_ui/components/Component_SearchResults/index.d.ts

@@ -0,0 +1 @@
+export * from './Component_SearchResults.js';

package/_ui/components/Component_SearchResults/index.js

@@ -0,0 +1 @@
+export * from './Component_SearchResults.js';

package/_ui/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Component_SearchMeta/index.js';
+export * from './Component_SearchResults/index.js';
+export * from './Component_SearchAddOn.js';

package/_ui/components/index.js

@@ -0,0 +1,3 @@
+export * from './Component_SearchMeta/index.js';
+export * from './Component_SearchResults/index.js';
+export * from './Component_SearchAddOn.js';

package/_ui/index.d.ts

@@ -0,0 +1,3 @@
+export * from './add-ons/index.js';
+export * from './components/index.js';
+export * from './sorters/index.js';

package/_ui/index.js

@@ -0,0 +1,3 @@
+export * from './add-ons/index.js';
+export * from './components/index.js';
+export * from './sorters/index.js';

package/_ui/sorters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './search-term/SearchSorter_SearchTerm.js';
+export * from './search-terms/SearchSorter_SearchTerms.js';

package/_ui/sorters/index.js

@@ -0,0 +1,2 @@
+export * from './search-term/SearchSorter_SearchTerm.js';
+export * from './search-terms/SearchSorter_SearchTerms.js';

package/_ui/sorters/search-term/SearchSorter_SearchTerm.d.ts

@@ -0,0 +1,3 @@
+import { SearchSorter } from '../../../_core/SearchSorter.js';
+import { AddOnDef_SearchTerm } from '../../add-ons/search-term/index.js';
+export declare const SearchSorter_SearchTerm: SearchSorter<AddOnDef_SearchTerm>;

package/_ui/sorters/search-term/SearchSorter_SearchTerm.js

@@ -0,0 +1,8 @@
+import { sortArray } from '@nu-art/ts-common';
+export const SearchSorter_SearchTerm = {
+    key: 'searchTerm',
+    sortFunction: (results) => {
+        sortArray(results, result => result.filterResults[SearchSorter_SearchTerm.key].value.length);
+        sortArray(results, result => result.filterResults[SearchSorter_SearchTerm.key].score);
+    }
+};

package/_ui/sorters/search-terms/SearchSorter_SearchTerms.d.ts

@@ -0,0 +1,3 @@
+import { SearchSorter } from '../../../_core/SearchSorter.js';
+import { AddOnDef_SearchTerms } from '../../add-ons/search-terms/types.js';
+export declare const SearchSorter_SearchTerms: SearchSorter<AddOnDef_SearchTerms>;

package/_ui/sorters/search-terms/SearchSorter_SearchTerms.js

@@ -0,0 +1,8 @@
+import { sortArray } from '@nu-art/ts-common';
+export const SearchSorter_SearchTerms = {
+    key: 'searchTerms',
+    sortFunction: (results) => {
+        sortArray(results, result => result.filterResults[SearchSorter_SearchTerms.key].value.length);
+        sortArray(results, result => result.filterResults[SearchSorter_SearchTerms.key].score);
+    }
+};

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './_core/index.js';
+export * from './_ui/index.js';

package/index.js

@@ -0,0 +1,2 @@
+export * from './_core/index.js';
+export * from './_ui/index.js';

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@nu-art/search",
+  "version": "0.400.7",
+  "description": "Search",
+  "keywords": [
+    "TacB0sS",
+    "express",
+    "infra",
+    "nu-art",
+    "thunderstorm",
+    "typescript"
+  ],
+  "homepage": "https://github.com/nu-art-js/thunderstorm",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "scripts": {
+    "build": "tsc"
+  },
+  "contributors": [
+    {
+      "name": "TacB0sS"
+    },
+    {
+      "name": "Cipher",
+      "url": "https://www.linkedin.com/in/itay-leybovich-470b87229/"
+    }
+  ],
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "dependencies": {
+    "@nu-art/ts-common": "0.400.7",
+    "@nu-art/ts-styles": "0.400.7",
+    "@nu-art/thunderstorm-frontend": "0.400.7",
+    "react": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}