@himanshu-sorathiya/react-kit 1.0.16 → 1.0.18

package/dist/performance.d.ts

@@ -0,0 +1,29 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export interface DebounceOptions {
+	maxWait?: number;
+	leading?: boolean;
+	trailing?: boolean;
+}
+export interface UseDebounceReturn<Args extends any[]> {
+	debouncedFunc: (...args: Args) => void;
+	cancel: () => void;
+	flush: () => void;
+	isPending: boolean;
+}
+export declare function useDebounce<Args extends any[]>(func: (...args: Args) => void, delay: number, options?: DebounceOptions): UseDebounceReturn<Args>;
+export type UseDebouncedValueReturn<T> = T;
+export declare function useDebouncedValue<T>(value: T, delay: number, options?: DebounceOptions): UseDebouncedValueReturn<T>;
+export interface ThrottleOptions {
+	leading?: boolean;
+	trailing?: boolean;
+}
+export interface UseThrottleReturn<Args extends any[]> {
+	throttledFunc: (...args: Args) => void;
+	cancel: () => void;
+	flush: () => void;
+	isPending: boolean;
+}
+export declare function useThrottle<Args extends any[]>(func: (...args: Args) => void, delay: number, options?: ThrottleOptions): UseThrottleReturn<Args>;
+
+export {};

package/dist/performance.js

@@ -0,0 +1,2 @@
+import { n as e, r as t, t as n } from "./performance2.js";
+export { t as useDebounce, e as useDebouncedValue, n as useThrottle };

package/dist/performance2.js

@@ -0,0 +1,77 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+//#region src/performance/useDebounce/useDebounce.ts
+function i(i, a, o = {}) {
+	let [s, c] = r(!1), l = o.maxWait, u = !!o.leading, d = !u && o.trailing === !1 ? !0 : o.trailing ?? !u, f = n(i), p = n(null), m = n(-1), h = n(-1), g = n(null);
+	t(() => {
+		f.current = i;
+	}, [i]);
+	let _ = e(() => {
+		p.current &&= (clearTimeout(p.current), null), m.current = -1, h.current = -1, g.current = null, c(!1);
+	}, []), v = e(() => {
+		p.current && g.current && (clearTimeout(p.current), p.current = null, f.current(...g.current), m.current = Date.now(), h.current = -1, g.current = null, c(!1));
+	}, []);
+	return t(() => () => {
+		_();
+	}, [_]), {
+		debouncedFunc: e((...e) => {
+			c(!0), h.current = Date.now(), g.current = e, m.current === -1 && (m.current = Date.now(), u === !0 && f.current(...e)), l !== void 0 && Date.now() - m.current >= l ? (p.current && clearTimeout(p.current), f.current(...e), m.current = -1, c(!1)) : (p.current && clearTimeout(p.current), p.current = setTimeout(() => {
+				h.current !== m.current && d !== !1 && f.current(...e), m.current = -1, c(!1);
+			}, a));
+		}, [
+			a,
+			l,
+			d,
+			u
+		]),
+		cancel: _,
+		flush: v,
+		isPending: s
+	};
+}
+//#endregion
+//#region src/performance/useDebounce/useDebouncedValue.ts
+function a(e, n, a = {}) {
+	let [o, s] = r(e), { debouncedFunc: c } = i((e) => {
+		s(e);
+	}, n, a);
+	return t(() => {
+		c(e);
+	}, [e, c]), o;
+}
+//#endregion
+//#region src/performance/useThrottle/useThrottle.ts
+function o(i, a, o = {}) {
+	let [s, c] = r(!1), l = o.leading ?? !0, u = o.trailing ?? !0, d = n(i), f = n(null), p = n(-1), m = n(null);
+	t(() => {
+		d.current = i;
+	}, [i]);
+	let h = e(() => {
+		f.current &&= (clearTimeout(f.current), null), p.current = -1, m.current = null, c(!1);
+	}, []), g = e(() => {
+		m.current && (f.current &&= (clearTimeout(f.current), null), d.current(...m.current), p.current = l ? Date.now() : -1, m.current = null, c(!1));
+	}, [l]);
+	return t(() => () => {
+		h();
+	}, [h]), {
+		throttledFunc: e((...e) => {
+			c(!0);
+			let t = Date.now();
+			if (m.current = e, p.current === -1 ? l : t - p.current >= a) f.current &&= (clearTimeout(f.current), null), d.current(...e), p.current = t, m.current = null, c(!1);
+			else if (!f.current) {
+				let e = a - (p.current === -1 ? 0 : t - p.current);
+				f.current = setTimeout(() => {
+					u && m.current ? (d.current(...m.current), p.current = l ? Date.now() : -1) : p.current = -1, m.current = null, f.current = null, c(!1);
+				}, e);
+			}
+		}, [
+			a,
+			l,
+			u
+		]),
+		cancel: h,
+		flush: g,
+		isPending: s
+	};
+}
+//#endregion
+export { a as n, i as r, o as t };

package/dist/state.d.ts

@@ -0,0 +1,235 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type FilterType = "text" | "number" | "boolean" | "date" | "select" | "multiselect" | "custom";
+export type TextOperator = "contains" | "equals" | "startsWith" | "endsWith" | "notContains";
+export type NumberOperator = "equals" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "between";
+export type BooleanOperator = "equals";
+export type DateOperator = "equals" | "before" | "after" | "between";
+export type SelectOperator = "equals" | "notEquals";
+export type MultiselectOperator = "in" | "notIn" | "intersects";
+export type CustomOperator = "custom";
+export interface FilterOptions<T = unknown> {
+	caseSensitive?: boolean;
+	compare?: (itemValue: unknown, filterValue: unknown, item: T) => boolean;
+}
+export type BaseFilterConfig<T> = FilterOptions<T> & {
+	id: string;
+	field: string;
+	isActive?: boolean;
+};
+export type FilterConfig<T = unknown> = BaseFilterConfig<T> & ({
+	type: "text";
+	operator: TextOperator;
+	value: string;
+} | {
+	type: "number";
+	operator: "between";
+	value: {
+		min: number;
+		max: number;
+	};
+} | {
+	type: "number";
+	operator: Exclude<NumberOperator, "between">;
+	value: number;
+} | {
+	type: "boolean";
+	operator: BooleanOperator;
+	value: boolean;
+} | {
+	type: "date";
+	operator: "between";
+	value: {
+		min: string | number | Date;
+		max: string | number | Date;
+	};
+} | {
+	type: "date";
+	operator: Exclude<DateOperator, "between">;
+	value: string | number | Date;
+} | {
+	type: "select";
+	operator: SelectOperator;
+	value: string | number;
+} | {
+	type: "multiselect";
+	operator: MultiselectOperator;
+	value: (string | number)[];
+} | {
+	type: "custom";
+	operator: CustomOperator;
+	value: unknown;
+});
+export type FilterState<T> = FilterConfig<T>[];
+export interface UseFilterReturn<T> {
+	filteredItems: T[];
+	filters: FilterState<T>;
+	upsertFilter: (filter: FilterConfig<T>) => void;
+	removeFilter: (id: string | string[]) => void;
+	clearFilters: () => void;
+	resetFilters: () => void;
+	replaceFilters: (filters: FilterConfig<T>[]) => void;
+	toggleFilter: (filter: FilterConfig<T>) => void;
+	updateFilterConfig: (id: string, partialConfig: Partial<Omit<FilterConfig<T>, "id">>) => void;
+	getFilterValue: (id: string) => unknown;
+	updateFilterValue: (id: string, value: unknown) => void;
+	isFilterActive: (id: string) => boolean;
+}
+export declare function useFilter<T>(data: T[], initialFilters?: FilterState<T>): UseFilterReturn<T>;
+export interface FuzzySearchOptions {
+	threshold?: number;
+	caseSensitive?: boolean;
+	matchStrategy?: "any" | "all";
+	exactPhraseBonus?: boolean;
+}
+export interface IndexedToken {
+	text: string;
+	weight: number;
+}
+export interface FlatIndexedItem<T> {
+	item: T;
+	index: number;
+	tokens: IndexedToken[];
+	combinedFlatText: string;
+}
+export interface ScoredItem<T> {
+	item: T;
+	score: number;
+	index: number;
+}
+export type UseFuzzySearchFields<T> = {
+	field: Extract<keyof T, string>;
+	weight: number;
+}[];
+export type UseFuzzySearchReturn<T> = T[];
+export declare function useFuzzySearch<T>(data: T[], query: string, fields: UseFuzzySearchFields<T>, options?: FuzzySearchOptions): UseFuzzySearchReturn<T>;
+export interface Group<T> {
+	key: string;
+	items: T[];
+}
+export interface UseGroupingReturn<T> {
+	groupedRecord: Record<string, T[]>;
+	groupedArray: Group<T>[];
+	groupKeys: string[];
+	totalGroups: number;
+	activeGroupBy: string | undefined;
+	changeGroupBy: (newField: string) => void;
+	clearGrouping: () => void;
+	resetGrouping: () => void;
+	getGroupItems: (groupKey: string) => T[];
+}
+export declare function useGrouping<T = unknown>({ items, initialGroupBy, }: {
+	items: T[];
+	initialGroupBy?: string;
+}): UseGroupingReturn<T>;
+export type SelectionId = string | number;
+export interface UseMultipleSelectionReturn<T> {
+	selectedIds: SelectionId[];
+	selectedCount: number;
+	selectedItems: T[];
+	isEmpty: boolean;
+	select: (item: SelectionId | T) => void;
+	deselect: (item: SelectionId | T) => void;
+	toggle: (item: SelectionId | T) => void;
+	isSelected: (item: SelectionId | T) => boolean;
+	resetSelection: () => void;
+	replaceSelection: (newSelectedItems: SelectionId[] | T[]) => void;
+	selectAll: () => void;
+	deselectAll: () => void;
+	toggleAll: () => void;
+	invertSelection: () => void;
+	selectMultiple: (newItems: SelectionId[] | T[]) => void;
+	deselectMultiple: (itemsToRemove: SelectionId[] | T[]) => void;
+	retainOnly: (itemsToRetain: SelectionId[] | T[]) => void;
+}
+export declare function useMultipleSelection<T = unknown>({ items, field, initialSelectedIds, }: {
+	items: T[];
+	field?: string;
+	initialSelectedIds?: SelectionId[];
+}): UseMultipleSelectionReturn<T>;
+export interface UseOrderReturn<T> {
+	orderedItems: T[];
+	moveUp: (index: number) => void;
+	moveDown: (index: number) => void;
+	canMoveUp: (index: number) => boolean;
+	canMoveDown: (index: number) => boolean;
+	moveToTop: (index: number) => void;
+	moveToBottom: (index: number) => void;
+	move: (fromIndex: number, toIndex: number) => void;
+	swap: (indexA: number, indexB: number) => void;
+	resetOrder: () => void;
+	replaceOrder: (newOrderedItems: T[]) => void;
+}
+export declare function useOrder<T>(initialItems: T[]): UseOrderReturn<T>;
+export interface UsePaginationReturn<T> {
+	pageItems: T[];
+	pageSize: number;
+	pageIndex: number;
+	totalPages: number;
+	canPrevious: boolean;
+	canNext: boolean;
+	nextPage: () => void;
+	previousPage: () => void;
+	goToFirstPage: () => void;
+	goToLastPage: () => void;
+	goToPage: (newPageIndex: number) => void;
+	changePageSize: (newPageSize: number) => void;
+	resetPageIndex: () => void;
+	resetPageSize: () => void;
+	resetPagination: () => void;
+}
+export declare function usePagination<T>(data: T[], initialPageSize: number, initialPageIndex?: number): UsePaginationReturn<T>;
+type SelectionId$1 = string | number;
+export interface UseSingleSelectionReturn {
+	selectedId: SelectionId$1 | undefined;
+	hasSelection: boolean;
+	select: (id: SelectionId$1) => void;
+	deselect: () => void;
+	toggle: (id: SelectionId$1) => void;
+	isSelected: (id: SelectionId$1) => boolean;
+	resetSelection: () => void;
+}
+export declare function useSingleSelection(initialSelectedId?: SelectionId$1): UseSingleSelectionReturn;
+export type SortType = "numeric" | "alphabetical" | "alphanumeric" | "boolean" | "date" | "basic" | "custom";
+export interface BaseSortOptions {
+	desc?: boolean;
+	disableSortRemoval?: boolean;
+	invertSorting?: boolean;
+	sortUndefined?: "first" | "last" | -1 | 1;
+}
+export interface BaseSortConfig extends BaseSortOptions {
+	id: string;
+	field?: string;
+}
+export type SortConfig = BaseSortConfig & ({
+	type: "numeric" | "boolean" | "date" | "basic";
+} | {
+	type: "alphabetical" | "alphanumeric";
+	caseSensitive?: boolean;
+} | {
+	type: "custom";
+	compare: (a: unknown, b: unknown) => number;
+});
+export type SortState = SortConfig[];
+export type SortOptionsForType<T extends SortType> = Omit<Extract<SortConfig, {
+	type: T;
+}>, "id" | "type" | "field">;
+export interface UseSortReturn<T> {
+	sortedItems: T[];
+	sorts: SortState;
+	upsertSorts: (sort: SortConfig) => void;
+	removeSort: (id: string | string[]) => void;
+	clearSorts: () => void;
+	resetSorts: () => void;
+	replaceSorts: (sorts: SortState) => void;
+	toggleSort: <TType extends SortType>(id: string, type: TType, options?: SortOptionsForType<TType> & {
+		multi?: boolean;
+		field?: string;
+	}) => void;
+	getSortDirection: (id: string) => "asc" | "desc" | undefined;
+	getNextSortingOrder: (id: string) => "asc" | "desc" | "none";
+	getSortIndex: (id: string) => number | undefined;
+}
+export declare function useSort<T>(data: T[], initialSorts?: SortState): UseSortReturn<T>;
+
+export {};

package/dist/state.js

@@ -0,0 +1,2 @@
+import { a as e, c as t, i as n, n as r, o as i, r as a, s as o, t as s } from "./state2.js";
+export { t as useFilter, o as useFuzzySearch, i as useGrouping, e as useMultipleSelection, n as useOrder, a as usePagination, r as useSingleSelection, s as useSort };