@zayne-labs/toolkit-react 0.11.19 → 0.11.21

package/dist/esm/hooks/useSearchParams.js

@@ -0,0 +1,36 @@
+import { useLocationState } from "./useLocationState.js";
+import { createSearchParams } from "@zayne-labs/toolkit-core";
+import { isFunction } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/hooks/useSearchParams.ts
+const useSearchParams = (options) => {
+	const { action = "push",...restOfOptions } = options ?? {};
+	const [searchParams, actions] = useLocationState((state) => state.search, restOfOptions);
+	const setSearchParams = (newQueryParams) => {
+		const params = isFunction(newQueryParams) ? newQueryParams(searchParams) : newQueryParams;
+		const nextSearchParams = createSearchParams(params);
+		actions[action]({ search: nextSearchParams });
+	};
+	return [
+		searchParams,
+		setSearchParams,
+		actions.triggerPopstateEvent
+	];
+};
+const useSearchParamsObject = (options) => {
+	const [searchParams, setSearchParams, triggerPopstateEvent] = useSearchParams(options);
+	const searchParamsObject = Object.fromEntries(searchParams);
+	const setSearchParamsObject = (newQueryParams) => {
+		const params = isFunction(newQueryParams) ? newQueryParams(searchParamsObject) : newQueryParams;
+		setSearchParams(params);
+	};
+	return [
+		searchParamsObject,
+		setSearchParamsObject,
+		triggerPopstateEvent
+	];
+};
+
+//#endregion
+export { useSearchParams, useSearchParamsObject };
+//# sourceMappingURL=useSearchParams.js.map

package/dist/esm/hooks/useSearchParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSearchParams.js","names":[],"sources":["../../../src/hooks/useSearchParams.ts"],"sourcesContent":["import {\n\tcreateSearchParams,\n\ttype LocationStoreOptions,\n\ttype URLSearchParamsInit,\n} from \"@zayne-labs/toolkit-core\";\nimport { isFunction } from \"@zayne-labs/toolkit-type-helpers\";\nimport { useLocationState } from \"./useLocationState\";\n\ntype UseSearchParamsOptions = LocationStoreOptions & {\n\taction?: \"push\" | \"replace\";\n};\n\nexport const useSearchParams = <TSearchParams extends URLSearchParamsInit>(\n\toptions?: UseSearchParamsOptions\n) => {\n\tconst { action = \"push\", ...restOfOptions } = options ?? {};\n\n\tconst [searchParams, actions] = useLocationState((state) => state.search, restOfOptions);\n\n\tconst setSearchParams = (\n\t\tnewQueryParams: TSearchParams | ((prev: URLSearchParams) => TSearchParams)\n\t) => {\n\t\tconst params = isFunction(newQueryParams) ? newQueryParams(searchParams) : newQueryParams;\n\n\t\tconst nextSearchParams = createSearchParams(params);\n\n\t\tactions[action]({ search: nextSearchParams });\n\t};\n\n\treturn [searchParams, setSearchParams, actions.triggerPopstateEvent] as [\n\t\tsearchParams: typeof searchParams,\n\t\tsetSearchParams: typeof setSearchParams,\n\t\ttriggerPopstateEvent: typeof actions.triggerPopstateEvent,\n\t];\n};\n\nexport const useSearchParamsObject = <TSearchParams extends Record<string, string>>(\n\toptions?: UseSearchParamsOptions\n) => {\n\tconst [searchParams, setSearchParams, triggerPopstateEvent] = useSearchParams(options);\n\n\tconst searchParamsObject = Object.fromEntries(searchParams) as TSearchParams;\n\n\tconst setSearchParamsObject = (\n\t\tnewQueryParams: TSearchParams | ((prev: TSearchParams) => TSearchParams)\n\t) => {\n\t\tconst params = isFunction(newQueryParams) ? newQueryParams(searchParamsObject) : newQueryParams;\n\n\t\tsetSearchParams(params);\n\t};\n\n\treturn [searchParamsObject, setSearchParamsObject, triggerPopstateEvent] as [\n\t\tsearchParamsObject: typeof searchParamsObject,\n\t\tsetSearchParamsObject: typeof setSearchParamsObject,\n\t\ttriggerPopstateEvent: typeof triggerPopstateEvent,\n\t];\n};\n"],"mappings":";;;;;AAYA,MAAa,mBACZ,YACI;CACJ,MAAM,EAAE,SAAS,OAAQ,GAAG,kBAAkB,WAAW,EAAE;CAE3D,MAAM,CAAC,cAAc,WAAW,kBAAkB,UAAU,MAAM,QAAQ,cAAc;CAExF,MAAM,mBACL,mBACI;EACJ,MAAM,SAAS,WAAW,eAAe,GAAG,eAAe,aAAa,GAAG;EAE3E,MAAM,mBAAmB,mBAAmB,OAAO;AAEnD,UAAQ,QAAQ,EAAE,QAAQ,kBAAkB,CAAC;;AAG9C,QAAO;EAAC;EAAc;EAAiB,QAAQ;EAAqB;;AAOrE,MAAa,yBACZ,YACI;CACJ,MAAM,CAAC,cAAc,iBAAiB,wBAAwB,gBAAgB,QAAQ;CAEtF,MAAM,qBAAqB,OAAO,YAAY,aAAa;CAE3D,MAAM,yBACL,mBACI;EACJ,MAAM,SAAS,WAAW,eAAe,GAAG,eAAe,mBAAmB,GAAG;AAEjF,kBAAgB,OAAO;;AAGxB,QAAO;EAAC;EAAoB;EAAuB;EAAqB"}

package/dist/esm/hooks/useShallowCompare.d.ts

@@ -0,0 +1,8 @@
+import { SelectorFn } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/hooks/useShallowCompare.d.ts
+declare const useShallowCompSelector: <TState, TResult>(selector: SelectorFn<TState, TResult> | undefined) => (state: TState) => TResult;
+declare const useShallowCompValue: <TValue>(value: TValue) => TValue;
+//#endregion
+export { useShallowCompSelector, useShallowCompValue };
+//# sourceMappingURL=useShallowCompare.d.ts.map

package/dist/esm/hooks/useShallowCompare.js

@@ -0,0 +1,26 @@
+import { useCallbackRef } from "./useCallbackRef.js";
+import { useInsertionEffect, useRef } from "react";
+import { shallowCompare } from "@zayne-labs/toolkit-core";
+
+//#region src/hooks/useShallowCompare.ts
+const useShallowCompSelector = (selector) => {
+	const prevStateRef = useRef(void 0);
+	return useCallbackRef((state) => {
+		const nextState = selector?.(state);
+		if (!nextState) return prevStateRef.current;
+		if (shallowCompare(prevStateRef.current, nextState)) return prevStateRef.current;
+		return prevStateRef.current = nextState;
+	});
+};
+const useShallowCompValue = (value) => {
+	const prevValueRef = useRef(value);
+	useInsertionEffect(() => {
+		if (shallowCompare(prevValueRef.current, value)) return;
+		prevValueRef.current = value;
+	});
+	return prevValueRef.current;
+};
+
+//#endregion
+export { useShallowCompSelector, useShallowCompValue };
+//# sourceMappingURL=useShallowCompare.js.map

package/dist/esm/hooks/useShallowCompare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useShallowCompare.js","names":[],"sources":["../../../src/hooks/useShallowCompare.ts"],"sourcesContent":["import { shallowCompare } from \"@zayne-labs/toolkit-core\";\nimport type { SelectorFn } from \"@zayne-labs/toolkit-type-helpers\";\nimport { useInsertionEffect, useRef } from \"react\";\nimport { useCallbackRef } from \"./useCallbackRef\";\n\nexport const useShallowCompSelector = <TState, TResult>(\n\tselector: SelectorFn<TState, TResult> | undefined\n) => {\n\tconst prevStateRef = useRef<TResult>(undefined as never);\n\n\tconst shallowSelector = useCallbackRef((state: TState) => {\n\t\tconst nextState = selector?.(state);\n\n\t\tif (!nextState) {\n\t\t\treturn prevStateRef.current;\n\t\t}\n\n\t\tif (shallowCompare(prevStateRef.current, nextState)) {\n\t\t\treturn prevStateRef.current;\n\t\t}\n\n\t\treturn (prevStateRef.current = nextState);\n\t});\n\n\treturn shallowSelector;\n};\n\nexport const useShallowCompValue = <TValue>(value: TValue) => {\n\tconst prevValueRef = useRef<TValue>(value);\n\n\tuseInsertionEffect(() => {\n\t\tif (shallowCompare(prevValueRef.current, value)) return;\n\n\t\tprevValueRef.current = value;\n\t});\n\n\t// eslint-disable-next-line react-hooks/refs -- Allow this for convenience\n\treturn prevValueRef.current;\n};\n"],"mappings":";;;;;AAKA,MAAa,0BACZ,aACI;CACJ,MAAM,eAAe,OAAgB,OAAmB;AAgBxD,QAdwB,gBAAgB,UAAkB;EACzD,MAAM,YAAY,WAAW,MAAM;AAEnC,MAAI,CAAC,UACJ,QAAO,aAAa;AAGrB,MAAI,eAAe,aAAa,SAAS,UAAU,CAClD,QAAO,aAAa;AAGrB,SAAQ,aAAa,UAAU;GAC9B;;AAKH,MAAa,uBAA+B,UAAkB;CAC7D,MAAM,eAAe,OAAe,MAAM;AAE1C,0BAAyB;AACxB,MAAI,eAAe,aAAa,SAAS,MAAM,CAAE;AAEjD,eAAa,UAAU;GACtB;AAGF,QAAO,aAAa"}

package/dist/esm/hooks/useStorageState.d.ts

@@ -0,0 +1,20 @@
+import * as _zayne_labs_toolkit_core4 from "@zayne-labs/toolkit-core";
+import { StorageOptions, StorageStoreApi } from "@zayne-labs/toolkit-core";
+import { SelectorFn } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/hooks/useStorageState.d.ts
+type UseStorageResult<TState, TSlice = TState> = [state: TSlice, actions: StorageStoreApi<TState>];
+/**
+ * @description Creates a custom hook that returns a storage state and actions to modify it. You can use this if you need shared options.
+ * @note You must use this if you want to be able to prevent syncing state across tabs.
+ */
+declare const createUseStorageState: <TState>(baseOptions: StorageOptions<TState>) => _zayne_labs_toolkit_core4.StoreApi<TState> & {
+  removeState: () => void;
+} & (<TSlice = TState>(selector?: SelectorFn<TState, TSlice>) => UseStorageResult<TState, TSlice>);
+type UseStorageStateOptions<TValue> = Omit<StorageOptions<TValue>, "initialValue" | "key">;
+declare const useStorageState: <TValue, TSlice = TValue>(key: string, initialValue?: TValue, options?: UseStorageStateOptions<TValue> & {
+  select?: SelectorFn<TValue, TSlice>;
+}) => UseStorageResult<TValue, TSlice>;
+//#endregion
+export { createUseStorageState, useStorageState };
+//# sourceMappingURL=useStorageState.d.ts.map

package/dist/esm/hooks/useStorageState.js

@@ -0,0 +1,54 @@
+import { useCallbackRef } from "./useCallbackRef.js";
+import { useStore } from "./useStore.js";
+import { useMemo } from "react";
+import { createExternalStorageStore } from "@zayne-labs/toolkit-core";
+
+//#region src/hooks/useStorageState.ts
+/**
+* @description Creates a custom hook that returns a storage state and actions to modify it. You can use this if you need shared options.
+* @note You must use this if you want to be able to prevent syncing state across tabs.
+*/
+const createUseStorageState = (baseOptions) => {
+	const externalStore = createExternalStorageStore(baseOptions);
+	const useStorageState$1 = (selector) => {
+		return [useStore(externalStore, selector), externalStore];
+	};
+	Object.assign(useStorageState$1, externalStore);
+	return useStorageState$1;
+};
+const useStorageState = (key, initialValue, options) => {
+	const { equalityFn, logger, parser, partialize, select, serializer, storageArea, syncStateAcrossTabs } = options ?? {};
+	const savedEquality = useCallbackRef(equalityFn);
+	const savedLogger = useCallbackRef(logger);
+	const savedParser = useCallbackRef(parser);
+	const savedPartialize = useCallbackRef(partialize);
+	const savedSerializer = useCallbackRef(serializer);
+	const externalStore = useMemo(() => {
+		return createExternalStorageStore({
+			equalityFn: savedEquality,
+			initialValue,
+			key,
+			logger: savedLogger,
+			parser: savedParser,
+			partialize: savedPartialize,
+			serializer: savedSerializer,
+			storageArea,
+			syncStateAcrossTabs
+		});
+	}, [
+		initialValue,
+		key,
+		savedEquality,
+		savedLogger,
+		savedParser,
+		savedPartialize,
+		savedSerializer,
+		storageArea,
+		syncStateAcrossTabs
+	]);
+	return [useStore(externalStore, select), externalStore];
+};
+
+//#endregion
+export { createUseStorageState, useStorageState };
+//# sourceMappingURL=useStorageState.js.map

package/dist/esm/hooks/useStorageState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStorageState.js","names":["useStorageState"],"sources":["../../../src/hooks/useStorageState.ts"],"sourcesContent":["import {\n\tcreateExternalStorageStore,\n\ttype StorageOptions,\n\ttype StorageStoreApi,\n} from \"@zayne-labs/toolkit-core\";\nimport type { SelectorFn } from \"@zayne-labs/toolkit-type-helpers\";\nimport { useMemo } from \"react\";\nimport { useCallbackRef } from \"./useCallbackRef\";\nimport { useStore } from \"./useStore\";\n\ntype UseStorageResult<TState, TSlice = TState> = [state: TSlice, actions: StorageStoreApi<TState>];\n\n/**\n * @description Creates a custom hook that returns a storage state and actions to modify it. You can use this if you need shared options.\n * @note You must use this if you want to be able to prevent syncing state across tabs.\n */\nexport const createUseStorageState = <TState>(baseOptions: StorageOptions<TState>) => {\n\tconst externalStore = createExternalStorageStore(baseOptions);\n\n\ttype UseBoundStorageState = StorageStoreApi<TState>\n\t\t& (<TSlice = TState>(selector?: SelectorFn<TState, TSlice>) => UseStorageResult<TState, TSlice>);\n\n\tconst useStorageState = <TSlice = TState>(\n\t\tselector?: SelectorFn<TState, TSlice>\n\t): UseStorageResult<TState, TSlice> => {\n\t\tconst stateInStorage = useStore(externalStore, selector);\n\n\t\treturn [stateInStorage, externalStore];\n\t};\n\n\tObject.assign(useStorageState, externalStore);\n\n\treturn useStorageState as UseBoundStorageState;\n};\n\ntype UseStorageStateOptions<TValue> = Omit<StorageOptions<TValue>, \"initialValue\" | \"key\">;\n\nexport const useStorageState = <TValue, TSlice = TValue>(\n\tkey: string,\n\tinitialValue?: TValue,\n\toptions?: UseStorageStateOptions<TValue> & { select?: SelectorFn<TValue, TSlice> }\n): UseStorageResult<TValue, TSlice> => {\n\tconst { equalityFn, logger, parser, partialize, select, serializer, storageArea, syncStateAcrossTabs } =\n\t\toptions ?? {};\n\n\tconst savedEquality = useCallbackRef(equalityFn);\n\tconst savedLogger = useCallbackRef(logger);\n\tconst savedParser = useCallbackRef(parser);\n\tconst savedPartialize = useCallbackRef(partialize);\n\tconst savedSerializer = useCallbackRef(serializer);\n\n\tconst externalStore = useMemo(() => {\n\t\treturn createExternalStorageStore({\n\t\t\tequalityFn: savedEquality,\n\t\t\tinitialValue,\n\t\t\tkey,\n\t\t\tlogger: savedLogger,\n\t\t\tparser: savedParser,\n\t\t\tpartialize: savedPartialize,\n\t\t\tserializer: savedSerializer,\n\t\t\tstorageArea,\n\t\t\tsyncStateAcrossTabs,\n\t\t});\n\t}, [\n\t\tinitialValue,\n\t\tkey,\n\t\tsavedEquality,\n\t\tsavedLogger,\n\t\tsavedParser,\n\t\tsavedPartialize,\n\t\tsavedSerializer,\n\t\tstorageArea,\n\t\tsyncStateAcrossTabs,\n\t]);\n\n\tconst stateInStorage = useStore(externalStore as never, select as never);\n\n\treturn [stateInStorage as never, externalStore];\n};\n"],"mappings":";;;;;;;;;;AAgBA,MAAa,yBAAiC,gBAAwC;CACrF,MAAM,gBAAgB,2BAA2B,YAAY;CAK7D,MAAMA,qBACL,aACsC;AAGtC,SAAO,CAFgB,SAAS,eAAe,SAAS,EAEhC,cAAc;;AAGvC,QAAO,OAAOA,mBAAiB,cAAc;AAE7C,QAAOA;;AAKR,MAAa,mBACZ,KACA,cACA,YACsC;CACtC,MAAM,EAAE,YAAY,QAAQ,QAAQ,YAAY,QAAQ,YAAY,aAAa,wBAChF,WAAW,EAAE;CAEd,MAAM,gBAAgB,eAAe,WAAW;CAChD,MAAM,cAAc,eAAe,OAAO;CAC1C,MAAM,cAAc,eAAe,OAAO;CAC1C,MAAM,kBAAkB,eAAe,WAAW;CAClD,MAAM,kBAAkB,eAAe,WAAW;CAElD,MAAM,gBAAgB,cAAc;AACnC,SAAO,2BAA2B;GACjC,YAAY;GACZ;GACA;GACA,QAAQ;GACR,QAAQ;GACR,YAAY;GACZ,YAAY;GACZ;GACA;GACA,CAAC;IACA;EACF;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,CAAC;AAIF,QAAO,CAFgB,SAAS,eAAwB,OAAgB,EAEvC,cAAc"}

package/dist/esm/hooks/useStore.d.ts

@@ -0,0 +1,8 @@
+import { StoreApi } from "@zayne-labs/toolkit-core";
+import { SelectorFn } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/hooks/useStore.d.ts
+declare const useStore: <TState, TSlice = TState>(store: StoreApi<TState>, selector?: SelectorFn<TState, TSlice>) => TSlice;
+//#endregion
+export { useStore };
+//# sourceMappingURL=useStore.d.ts.map

package/dist/esm/hooks/useStore.js

@@ -0,0 +1,13 @@
+import { useCallback, useDebugValue, useSyncExternalStore } from "react";
+
+//#region src/hooks/useStore.ts
+const identity = (value) => value;
+const useStore = (store, selector = identity) => {
+	const slice = useSyncExternalStore(store.subscribe, useCallback(() => selector(store.getState()), [store, selector]), useCallback(() => selector(store.getInitialState()), [store, selector]));
+	useDebugValue(slice);
+	return slice;
+};
+
+//#endregion
+export { useStore };
+//# sourceMappingURL=useStore.js.map

package/dist/esm/hooks/useStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStore.js","names":[],"sources":["../../../src/hooks/useStore.ts"],"sourcesContent":["import type { StoreApi } from \"@zayne-labs/toolkit-core\";\nimport type { SelectorFn } from \"@zayne-labs/toolkit-type-helpers\";\nimport { useCallback, useDebugValue, useSyncExternalStore } from \"react\";\n\nconst identity = <TState>(value: TState) => value;\n\nconst useStore = <TState, TSlice = TState>(\n\tstore: StoreApi<TState>,\n\tselector: SelectorFn<TState, TSlice> = identity as never\n) => {\n\tconst slice = useSyncExternalStore(\n\t\tstore.subscribe,\n\t\tuseCallback(() => selector(store.getState()), [store, selector]),\n\t\tuseCallback(() => selector(store.getInitialState()), [store, selector])\n\t);\n\n\tuseDebugValue(slice);\n\n\treturn slice;\n};\n\nexport { useStore };\n"],"mappings":";;;AAIA,MAAM,YAAoB,UAAkB;AAE5C,MAAM,YACL,OACA,WAAuC,aACnC;CACJ,MAAM,QAAQ,qBACb,MAAM,WACN,kBAAkB,SAAS,MAAM,UAAU,CAAC,EAAE,CAAC,OAAO,SAAS,CAAC,EAChE,kBAAkB,SAAS,MAAM,iBAAiB,CAAC,EAAE,CAAC,OAAO,SAAS,CAAC,CACvE;AAED,eAAc,MAAM;AAEpB,QAAO"}

package/dist/esm/hooks/useThrottle.d.ts

@@ -0,0 +1,15 @@
+import { CallbackFn } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/hooks/useThrottle.d.ts
+declare const useThrottleBySetTimeout: <TParams>(callbackFn: CallbackFn<TParams>, delay: number) => {
+  (...params: TParams[]): void;
+  cancelTimeout(): void;
+};
+declare const useThrottleByTimer: <TParams>(callbackFn: CallbackFn<TParams>, delay: number) => (...params: TParams[]) => void;
+declare const useThrottleByFrame: <TParams>(callbackFn: CallbackFn<TParams>) => {
+  (...params: TParams[]): void;
+  cancelAnimation(): void;
+};
+//#endregion
+export { useThrottleByFrame, useThrottleBySetTimeout, useThrottleByTimer };
+//# sourceMappingURL=useThrottle.d.ts.map

package/dist/esm/hooks/useThrottle.js

@@ -0,0 +1,27 @@
+import { useCallbackRef } from "./useCallbackRef.js";
+import { useUnmountEffect } from "./effects/useUnMountEffect.js";
+import { useConstant } from "./useConstant.js";
+import { useMemo } from "react";
+import { throttleByFrame, throttleBySetTimeout, throttleByTime } from "@zayne-labs/toolkit-core";
+
+//#region src/hooks/useThrottle.ts
+const useThrottleBySetTimeout = (callbackFn, delay) => {
+	const latestCallback = useCallbackRef(callbackFn);
+	const throttledCallback = useMemo(() => throttleBySetTimeout(latestCallback, delay), [delay, latestCallback]);
+	useUnmountEffect(() => throttledCallback.cancelTimeout());
+	return throttledCallback;
+};
+const useThrottleByTimer = (callbackFn, delay) => {
+	const latestCallback = useCallbackRef(callbackFn);
+	return useMemo(() => throttleByTime(latestCallback, delay), [delay, latestCallback]);
+};
+const useThrottleByFrame = (callbackFn) => {
+	const latestCallback = useCallbackRef(callbackFn);
+	const throttledCallback = useConstant(() => throttleByFrame(latestCallback));
+	useUnmountEffect(() => throttledCallback.cancelAnimation());
+	return throttledCallback;
+};
+
+//#endregion
+export { useThrottleByFrame, useThrottleBySetTimeout, useThrottleByTimer };
+//# sourceMappingURL=useThrottle.js.map

package/dist/esm/hooks/useThrottle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useThrottle.js","names":[],"sources":["../../../src/hooks/useThrottle.ts"],"sourcesContent":["import { throttleByFrame, throttleBySetTimeout, throttleByTime } from \"@zayne-labs/toolkit-core\";\nimport type { CallbackFn } from \"@zayne-labs/toolkit-type-helpers\";\nimport { useMemo } from \"react\";\nimport { useUnmountEffect } from \"./effects\";\nimport { useCallbackRef } from \"./useCallbackRef\";\nimport { useConstant } from \"./useConstant\";\n\nexport const useThrottleBySetTimeout = <TParams>(callbackFn: CallbackFn<TParams>, delay: number) => {\n\tconst latestCallback = useCallbackRef(callbackFn);\n\n\tconst throttledCallback = useMemo(\n\t\t() => throttleBySetTimeout(latestCallback, delay),\n\t\t[delay, latestCallback]\n\t);\n\n\tuseUnmountEffect(() => throttledCallback.cancelTimeout());\n\n\treturn throttledCallback;\n};\n\nexport const useThrottleByTimer = <TParams>(callbackFn: CallbackFn<TParams>, delay: number) => {\n\tconst latestCallback = useCallbackRef(callbackFn);\n\n\tconst throttledCallback = useMemo(() => throttleByTime(latestCallback, delay), [delay, latestCallback]);\n\n\treturn throttledCallback;\n};\n\nexport const useThrottleByFrame = <TParams>(callbackFn: CallbackFn<TParams>) => {\n\tconst latestCallback = useCallbackRef(callbackFn);\n\n\tconst throttledCallback = useConstant(() => throttleByFrame(latestCallback));\n\n\tuseUnmountEffect(() => throttledCallback.cancelAnimation());\n\n\treturn throttledCallback;\n};\n"],"mappings":";;;;;;;AAOA,MAAa,2BAAoC,YAAiC,UAAkB;CACnG,MAAM,iBAAiB,eAAe,WAAW;CAEjD,MAAM,oBAAoB,cACnB,qBAAqB,gBAAgB,MAAM,EACjD,CAAC,OAAO,eAAe,CACvB;AAED,wBAAuB,kBAAkB,eAAe,CAAC;AAEzD,QAAO;;AAGR,MAAa,sBAA+B,YAAiC,UAAkB;CAC9F,MAAM,iBAAiB,eAAe,WAAW;AAIjD,QAF0B,cAAc,eAAe,gBAAgB,MAAM,EAAE,CAAC,OAAO,eAAe,CAAC;;AAKxG,MAAa,sBAA+B,eAAoC;CAC/E,MAAM,iBAAiB,eAAe,WAAW;CAEjD,MAAM,oBAAoB,kBAAkB,gBAAgB,eAAe,CAAC;AAE5E,wBAAuB,kBAAkB,iBAAiB,CAAC;AAE3D,QAAO"}

package/dist/esm/hooks/useToggle.d.ts

@@ -0,0 +1,6 @@
+//#region src/hooks/useToggle.d.ts
+type InitialState = boolean | (() => boolean);
+declare const useToggle: (initialValue?: InitialState) => [value: boolean, toggleValue: <TValue>(newValue?: TValue) => void];
+//#endregion
+export { useToggle };
+//# sourceMappingURL=useToggle.d.ts.map

package/dist/esm/hooks/useToggle.js

@@ -0,0 +1,18 @@
+import { useCallback, useState } from "react";
+
+//#region src/hooks/useToggle.ts
+const useToggle = (initialValue = false) => {
+	const [value, setValue] = useState(initialValue);
+	const toggleValue = useCallback((newValue) => {
+		if (typeof newValue === "boolean") {
+			setValue(newValue);
+			return;
+		}
+		setValue((prev) => !prev);
+	}, []);
+	return [value, toggleValue];
+};
+
+//#endregion
+export { useToggle };
+//# sourceMappingURL=useToggle.js.map

package/dist/esm/hooks/useToggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToggle.js","names":[],"sources":["../../../src/hooks/useToggle.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\n\ntype InitialState = boolean | (() => boolean);\n\nconst useToggle = (initialValue: InitialState = false) => {\n\tconst [value, setValue] = useState(initialValue);\n\n\tconst toggleValue = useCallback(<TValue>(newValue?: TValue) => {\n\t\tif (typeof newValue === \"boolean\") {\n\t\t\tsetValue(newValue);\n\t\t\treturn;\n\t\t}\n\n\t\tsetValue((prev) => !prev);\n\t}, []);\n\n\treturn [value, toggleValue] as [value: typeof value, toggleValue: typeof toggleValue];\n};\n\nexport { useToggle };\n"],"mappings":";;;AAIA,MAAM,aAAa,eAA6B,UAAU;CACzD,MAAM,CAAC,OAAO,YAAY,SAAS,aAAa;CAEhD,MAAM,cAAc,aAAqB,aAAsB;AAC9D,MAAI,OAAO,aAAa,WAAW;AAClC,YAAS,SAAS;AAClB;;AAGD,YAAU,SAAS,CAAC,KAAK;IACvB,EAAE,CAAC;AAEN,QAAO,CAAC,OAAO,YAAY"}

package/dist/esm/utils/composeEventHandlers.d.ts

@@ -0,0 +1,8 @@
+import { AnyFunction } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/utils/composeEventHandlers.d.ts
+declare const composeTwoEventHandlers: (formerHandler: AnyFunction | undefined, latterHandler: AnyFunction | undefined) => (event: unknown) => unknown;
+declare const composeEventHandlers: (...eventHandlerArray: Array<AnyFunction | undefined>) => (event: unknown) => unknown;
+//#endregion
+export { composeEventHandlers, composeTwoEventHandlers };
+//# sourceMappingURL=composeEventHandlers.d.ts.map

package/dist/esm/utils/composeEventHandlers.js

@@ -0,0 +1,36 @@
+import { isObject } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/utils/composeEventHandlers.ts
+const isSyntheticEvent = (event) => {
+	return isObject(event) && Object.hasOwn(event, "nativeEvent");
+};
+const composeTwoEventHandlers = (formerHandler, latterHandler) => {
+	const mergedEventHandler = (event) => {
+		if (isSyntheticEvent(event)) {
+			const result$1 = latterHandler?.(event);
+			if (!event.defaultPrevented) formerHandler?.(event);
+			return result$1;
+		}
+		const result = latterHandler?.(event);
+		formerHandler?.(event);
+		return result;
+	};
+	return mergedEventHandler;
+};
+const composeEventHandlers = (...eventHandlerArray) => {
+	const mergedEventHandler = (event) => {
+		if (eventHandlerArray.length === 0) return;
+		if (eventHandlerArray.length === 1) return eventHandlerArray[0]?.(event);
+		let accumulatedHandlers;
+		for (const eventHandler of eventHandlerArray) {
+			if (!eventHandler) continue;
+			accumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);
+		}
+		return accumulatedHandlers?.(event);
+	};
+	return mergedEventHandler;
+};
+
+//#endregion
+export { composeEventHandlers, composeTwoEventHandlers };
+//# sourceMappingURL=composeEventHandlers.js.map

package/dist/esm/utils/composeEventHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeEventHandlers.js","names":["result","accumulatedHandlers: AnyFunction | undefined"],"sources":["../../../src/utils/composeEventHandlers.ts"],"sourcesContent":["import { type AnyFunction, isObject } from \"@zayne-labs/toolkit-type-helpers\";\n\nconst isSyntheticEvent = (event: unknown): event is React.SyntheticEvent => {\n\treturn isObject(event) && Object.hasOwn(event, \"nativeEvent\");\n};\n\nexport const composeTwoEventHandlers = (\n\tformerHandler: AnyFunction | undefined,\n\tlatterHandler: AnyFunction | undefined\n) => {\n\tconst mergedEventHandler = (event: unknown) => {\n\t\tif (isSyntheticEvent(event)) {\n\t\t\tconst result = latterHandler?.(event) as unknown;\n\n\t\t\tif (!event.defaultPrevented) {\n\t\t\t\tformerHandler?.(event);\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tconst result = latterHandler?.(event) as unknown;\n\t\tformerHandler?.(event);\n\t\treturn result;\n\t};\n\n\treturn mergedEventHandler;\n};\n\nexport const composeEventHandlers = (...eventHandlerArray: Array<AnyFunction | undefined>) => {\n\tconst mergedEventHandler = (event: unknown) => {\n\t\tif (eventHandlerArray.length === 0) return;\n\n\t\tif (eventHandlerArray.length === 1) {\n\t\t\treturn eventHandlerArray[0]?.(event) as unknown;\n\t\t}\n\n\t\tlet accumulatedHandlers: AnyFunction | undefined;\n\n\t\tfor (const eventHandler of eventHandlerArray) {\n\t\t\tif (!eventHandler) continue;\n\n\t\t\taccumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);\n\t\t}\n\n\t\treturn accumulatedHandlers?.(event) as unknown;\n\t};\n\n\treturn mergedEventHandler;\n};\n"],"mappings":";;;AAEA,MAAM,oBAAoB,UAAkD;AAC3E,QAAO,SAAS,MAAM,IAAI,OAAO,OAAO,OAAO,cAAc;;AAG9D,MAAa,2BACZ,eACA,kBACI;CACJ,MAAM,sBAAsB,UAAmB;AAC9C,MAAI,iBAAiB,MAAM,EAAE;GAC5B,MAAMA,WAAS,gBAAgB,MAAM;AAErC,OAAI,CAAC,MAAM,iBACV,iBAAgB,MAAM;AAGvB,UAAOA;;EAGR,MAAM,SAAS,gBAAgB,MAAM;AACrC,kBAAgB,MAAM;AACtB,SAAO;;AAGR,QAAO;;AAGR,MAAa,wBAAwB,GAAG,sBAAsD;CAC7F,MAAM,sBAAsB,UAAmB;AAC9C,MAAI,kBAAkB,WAAW,EAAG;AAEpC,MAAI,kBAAkB,WAAW,EAChC,QAAO,kBAAkB,KAAK,MAAM;EAGrC,IAAIC;AAEJ,OAAK,MAAM,gBAAgB,mBAAmB;AAC7C,OAAI,CAAC,aAAc;AAEnB,yBAAsB,wBAAwB,qBAAqB,aAAa;;AAGjF,SAAO,sBAAsB,MAAM;;AAGpC,QAAO"}

package/dist/esm/utils/composeRefs.d.ts

@@ -0,0 +1,17 @@
+import { RefCallback } from "react";
+
+//#region src/utils/composeRefs.d.ts
+type PossibleRef<TRef extends HTMLElement> = React.Ref<TRef> | undefined;
+/**
+ * @description Set a given ref to a given value.
+ *
+ * This utility takes care of different types of refs: callback refs and RefObject(s)
+ */
+declare const setRef: <TRef extends HTMLElement>(ref: PossibleRef<TRef>, node: TRef | null) => ReturnType<RefCallback<TRef>>;
+/**
+ * @description A utility to combine refs. Accepts callback refs and RefObject(s)
+ */
+declare const composeRefs: <TRef extends HTMLElement>(...refs: Array<PossibleRef<TRef>>) => RefCallback<TRef>;
+//#endregion
+export { PossibleRef, composeRefs, setRef };
+//# sourceMappingURL=composeRefs.d.ts.map

package/dist/esm/utils/composeRefs.js

@@ -0,0 +1,28 @@
+import { isFunction } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/utils/composeRefs.ts
+/**
+* @description Set a given ref to a given value.
+*
+* This utility takes care of different types of refs: callback refs and RefObject(s)
+*/
+const setRef = (ref, node) => {
+	if (!ref) return;
+	if (isFunction(ref)) return ref(node);
+	ref.current = node;
+};
+/**
+* @description A utility to combine refs. Accepts callback refs and RefObject(s)
+*/
+const composeRefs = (...refs) => {
+	const mergedRefCallBack = (node) => {
+		const cleanupFnArray = refs.map((ref) => setRef(ref, node));
+		const cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());
+		return cleanupFn;
+	};
+	return mergedRefCallBack;
+};
+
+//#endregion
+export { composeRefs, setRef };
+//# sourceMappingURL=composeRefs.js.map

package/dist/esm/utils/composeRefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeRefs.js","names":["mergedRefCallBack: RefCallback<TRef>"],"sources":["../../../src/utils/composeRefs.ts"],"sourcesContent":["import { isFunction } from \"@zayne-labs/toolkit-type-helpers\";\nimport type { RefCallback } from \"react\";\n\nexport type PossibleRef<TRef extends HTMLElement> = React.Ref<TRef> | undefined;\n\n/**\n * @description Set a given ref to a given value.\n *\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */\nexport const setRef = <TRef extends HTMLElement>(\n\tref: PossibleRef<TRef>,\n\tnode: TRef | null\n): ReturnType<RefCallback<TRef>> => {\n\tif (!ref) return;\n\n\tif (isFunction(ref)) {\n\t\treturn ref(node);\n\t}\n\n\t// eslint-disable-next-line no-param-reassign -- Mutation is needed here\n\tref.current = node;\n};\n\n/**\n * @description A utility to combine refs. Accepts callback refs and RefObject(s)\n */\nexport const composeRefs = <TRef extends HTMLElement>(\n\t...refs: Array<PossibleRef<TRef>>\n): RefCallback<TRef> => {\n\tconst mergedRefCallBack: RefCallback<TRef> = (node) => {\n\t\tconst cleanupFnArray = refs.map((ref) => setRef(ref, node));\n\n\t\tconst cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());\n\n\t\treturn cleanupFn;\n\t};\n\n\treturn mergedRefCallBack;\n};\n"],"mappings":";;;;;;;;AAUA,MAAa,UACZ,KACA,SACmC;AACnC,KAAI,CAAC,IAAK;AAEV,KAAI,WAAW,IAAI,CAClB,QAAO,IAAI,KAAK;AAIjB,KAAI,UAAU;;;;;AAMf,MAAa,eACZ,GAAG,SACoB;CACvB,MAAMA,qBAAwC,SAAS;EACtD,MAAM,iBAAiB,KAAK,KAAK,QAAQ,OAAO,KAAK,KAAK,CAAC;EAE3D,MAAM,kBAAkB,eAAe,SAAS,YAAY,WAAW,CAAC;AAExE,SAAO;;AAGR,QAAO"}

package/dist/esm/utils/getSlot/getSlot.d.ts

@@ -0,0 +1,60 @@
+import * as react13 from "react";
+import { Prettify, UnknownObject } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/utils/getSlot/getSlot.d.ts
+type FunctionalComponent<TProps extends UnknownObject = never> = React.FunctionComponent<TProps>;
+/**
+ * @description Checks if a react child (within the children array) matches the provided SlotComponent using multiple matching strategies:
+ * 1. Matches by slot symbol property
+ * 2. Matches by component name
+ */
+declare const matchesSlotComponent: (child: React.ReactNode, SlotComponent: FunctionalComponent) => boolean;
+/**
+ * @description Checks if a react child (within the children array) matches any of the provided SlotComponents.
+ */
+declare const matchesAnySlotComponent: (child: React.ReactNode, SlotComponents: FunctionalComponent[]) => boolean;
+type SlotOptions = {
+  /**
+   * @description The error message to throw when multiple slots are found for a given slot component
+   */
+  errorMessage?: string;
+  /**
+   * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component
+   */
+  throwOnMultipleSlotMatch?: boolean;
+};
+/**
+ * @description Retrieves a single slot element from a collection of React children that matches the provided SlotComponent component.
+ *
+ * @throws { AssertionError } when throwOnMultipleSlotMatch is true and multiple slots are found
+ */
+declare const getSingleSlot: (children: React.ReactNode, SlotComponent: FunctionalComponent, options?: SlotOptions) => react13.ReactNode;
+type MultipleSlotsOptions = {
+  /**
+   * @description The error message to throw when multiple slots are found for a given slot component
+   * If a string is provided, the same message will be used for all slot components
+   * If an array is provided, each string in the array will be used as the errorMessage for the corresponding slot component
+   */
+  errorMessage?: string | string[];
+  /**
+   * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component
+   * If a boolean is provided, the same value will be used for all slot components
+   * If an array is provided, each boolean in the array will be used as the throwOnMultipleSlotMatch value for the corresponding slot component
+   */
+  throwOnMultipleSlotMatch?: boolean | boolean[];
+};
+type GetMultipleSlotsResult<TSlotComponents extends FunctionalComponent[]> = {
+  regularChildren: React.ReactNode[];
+  slots: { [Key in keyof TSlotComponents]: ReturnType<TSlotComponents[Key]> };
+};
+/**
+ * @description The same as getSingleSlot, but for multiple slot components
+ */
+declare const getMultipleSlots: <const TSlotComponents extends FunctionalComponent[]>(children: React.ReactNode, SlotComponents: TSlotComponents, options?: MultipleSlotsOptions) => Prettify<GetMultipleSlotsResult<TSlotComponents>>;
+/**
+ * @description Returns all children that are not slot elements (i.e., don't match any of the provided slot components)
+ */
+declare const getRegularChildren: (children: React.ReactNode, SlotComponentOrComponents: FunctionalComponent | FunctionalComponent[]) => react13.ReactNode[];
+//#endregion
+export { FunctionalComponent, getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent };
+//# sourceMappingURL=getSlot.d.ts.map

package/dist/esm/utils/getSlot/getSlot.js

@@ -0,0 +1,78 @@
+import { Fragment, isValidElement } from "react";
+import { toArray } from "@zayne-labs/toolkit-core";
+import { AssertionError, isArray, isFunction } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/utils/getSlot/getSlot.ts
+const isWithSlotSymbol = (component) => {
+	return "slotSymbol" in component && Boolean(component.slotSymbol);
+};
+const isWithSlotReference = (component) => {
+	return "slotReference" in component && Boolean(component.slotReference);
+};
+/**
+* @description Checks if a react child (within the children array) matches the provided SlotComponent using multiple matching strategies:
+* 1. Matches by slot symbol property
+* 2. Matches by component name
+*/
+const matchesSlotComponent = (child, SlotComponent) => {
+	if (!isValidElement(child) || !isFunction(child.type)) return false;
+	const resolvedChildType = isWithSlotReference(child.type) ? child.type.slotReference : child.type;
+	if (isWithSlotSymbol(resolvedChildType) && isWithSlotSymbol(SlotComponent) && resolvedChildType.slotSymbol === SlotComponent.slotSymbol) return true;
+	if (child.type.name === SlotComponent.name) return true;
+	return false;
+};
+/**
+* @description Checks if a react child (within the children array) matches any of the provided SlotComponents.
+*/
+const matchesAnySlotComponent = (child, SlotComponents) => {
+	return SlotComponents.some((SlotComponent) => matchesSlotComponent(child, SlotComponent));
+};
+/**
+* @description Counts how many times a given slot component appears in an array of children
+* @internal
+*/
+const calculateSlotOccurrences = (childrenArray, SlotComponent) => {
+	let count = 0;
+	for (const child of childrenArray) {
+		if (!matchesSlotComponent(child, SlotComponent)) continue;
+		count += 1;
+	}
+	return count;
+};
+/**
+* @description Retrieves a single slot element from a collection of React children that matches the provided SlotComponent component.
+*
+* @throws { AssertionError } when throwOnMultipleSlotMatch is true and multiple slots are found
+*/
+const getSingleSlot = (children, SlotComponent, options = {}) => {
+	const { errorMessage = "Only one instance of the SlotComponent is allowed", throwOnMultipleSlotMatch = false } = options;
+	const actualChildren = isValidElement(children) && children.type === Fragment ? children.props.children : children;
+	const childrenArray = toArray(actualChildren);
+	if (throwOnMultipleSlotMatch && calculateSlotOccurrences(childrenArray, SlotComponent) > 1) throw new AssertionError(errorMessage);
+	return childrenArray.find((child) => matchesSlotComponent(child, SlotComponent));
+};
+/**
+* @description The same as getSingleSlot, but for multiple slot components
+*/
+const getMultipleSlots = (children, SlotComponents, options) => {
+	const { errorMessage, throwOnMultipleSlotMatch } = options ?? {};
+	const slots = SlotComponents.map((SlotComponent, index) => getSingleSlot(children, SlotComponent, {
+		errorMessage: isArray(errorMessage) ? errorMessage[index] : errorMessage,
+		throwOnMultipleSlotMatch: isArray(throwOnMultipleSlotMatch) ? throwOnMultipleSlotMatch[index] : throwOnMultipleSlotMatch
+	}));
+	return {
+		regularChildren: getRegularChildren(children, SlotComponents),
+		slots
+	};
+};
+/**
+* @description Returns all children that are not slot elements (i.e., don't match any of the provided slot components)
+*/
+const getRegularChildren = (children, SlotComponentOrComponents) => {
+	const actualChildren = isValidElement(children) && children.type === Fragment ? children.props.children : children;
+	return toArray(actualChildren).filter((child) => !matchesAnySlotComponent(child, toArray(SlotComponentOrComponents)));
+};
+
+//#endregion
+export { getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent };
+//# sourceMappingURL=getSlot.js.map

package/dist/esm/utils/getSlot/getSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSlot.js","names":["ReactFragment"],"sources":["../../../../src/utils/getSlot/getSlot.ts"],"sourcesContent":["import { toArray } from \"@zayne-labs/toolkit-core\";\nimport {\n\ttype AnyFunction,\n\tAssertionError,\n\tisArray,\n\tisFunction,\n\ttype Prettify,\n\ttype UnknownObject,\n} from \"@zayne-labs/toolkit-type-helpers\";\nimport { isValidElement, Fragment as ReactFragment } from \"react\";\nimport type { InferProps } from \"../types\";\n\nexport type FunctionalComponent<TProps extends UnknownObject = never> = React.FunctionComponent<TProps>;\n\nconst isWithSlotSymbol = <TFunction extends AnyFunction>(\n\tcomponent: TFunction\n): component is Record<\"slotSymbol\", unknown> & TFunction => {\n\treturn \"slotSymbol\" in component && Boolean(component.slotSymbol);\n};\n\nconst isWithSlotReference = <TFunction extends AnyFunction>(\n\tcomponent: TFunction\n): component is Record<\"slotReference\", unknown> & TFunction => {\n\treturn \"slotReference\" in component && Boolean(component.slotReference);\n};\n/**\n * @description Checks if a react child (within the children array) matches the provided SlotComponent using multiple matching strategies:\n * 1. Matches by slot symbol property\n * 2. Matches by component name\n */\n\nexport const matchesSlotComponent = (child: React.ReactNode, SlotComponent: FunctionalComponent) => {\n\tif (!isValidElement(child) || !isFunction(child.type)) {\n\t\treturn false;\n\t}\n\n\tconst resolvedChildType =\n\t\tisWithSlotReference(child.type) ? (child.type.slotReference as FunctionalComponent) : child.type;\n\n\tconst hasMatchingSlotSymbol =\n\t\tisWithSlotSymbol(resolvedChildType)\n\t\t&& isWithSlotSymbol(SlotComponent)\n\t\t&& resolvedChildType.slotSymbol === SlotComponent.slotSymbol;\n\n\tif (hasMatchingSlotSymbol) {\n\t\treturn true;\n\t}\n\n\tif (child.type.name === SlotComponent.name) {\n\t\treturn true;\n\t}\n\n\treturn false;\n};\n\n/**\n * @description Checks if a react child (within the children array) matches any of the provided SlotComponents.\n */\nexport const matchesAnySlotComponent = (child: React.ReactNode, SlotComponents: FunctionalComponent[]) => {\n\tconst matchesSlot = SlotComponents.some((SlotComponent) => matchesSlotComponent(child, SlotComponent));\n\n\treturn matchesSlot;\n};\n\ntype SlotOptions = {\n\t/**\n\t * @description The error message to throw when multiple slots are found for a given slot component\n\t */\n\terrorMessage?: string;\n\t/**\n\t * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component\n\t */\n\tthrowOnMultipleSlotMatch?: boolean;\n};\n\n/**\n * @description Counts how many times a given slot component appears in an array of children\n * @internal\n */\nconst calculateSlotOccurrences = (\n\tchildrenArray: React.ReactNode[],\n\tSlotComponent: FunctionalComponent\n) => {\n\tlet count = 0;\n\n\tfor (const child of childrenArray) {\n\t\tif (!matchesSlotComponent(child, SlotComponent)) continue;\n\n\t\tcount += 1;\n\t}\n\n\treturn count;\n};\n\n/**\n * @description Retrieves a single slot element from a collection of React children that matches the provided SlotComponent component.\n *\n * @throws { AssertionError } when throwOnMultipleSlotMatch is true and multiple slots are found\n */\nexport const getSingleSlot = (\n\tchildren: React.ReactNode,\n\tSlotComponent: FunctionalComponent,\n\toptions: SlotOptions = {}\n) => {\n\tconst {\n\t\terrorMessage = \"Only one instance of the SlotComponent is allowed\",\n\t\tthrowOnMultipleSlotMatch = false,\n\t} = options;\n\n\tconst actualChildren =\n\t\tisValidElement<InferProps<typeof ReactFragment>>(children) && children.type === ReactFragment ?\n\t\t\tchildren.props.children\n\t\t:\tchildren;\n\n\tconst childrenArray = toArray<React.ReactNode>(actualChildren);\n\n\tconst shouldThrow =\n\t\tthrowOnMultipleSlotMatch && calculateSlotOccurrences(childrenArray, SlotComponent) > 1;\n\n\tif (shouldThrow) {\n\t\tthrow new AssertionError(errorMessage);\n\t}\n\n\tconst slotElement = childrenArray.find((child) => matchesSlotComponent(child, SlotComponent));\n\n\treturn slotElement;\n};\n\n// NOTE -  You can imitate const type parameter by extending readonly[] | []\n\ntype MultipleSlotsOptions = {\n\t/**\n\t * @description The error message to throw when multiple slots are found for a given slot component\n\t * If a string is provided, the same message will be used for all slot components\n\t * If an array is provided, each string in the array will be used as the errorMessage for the corresponding slot component\n\t */\n\terrorMessage?: string | string[];\n\t/**\n\t * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component\n\t * If a boolean is provided, the same value will be used for all slot components\n\t * If an array is provided, each boolean in the array will be used as the throwOnMultipleSlotMatch value for the corresponding slot component\n\t */\n\tthrowOnMultipleSlotMatch?: boolean | boolean[];\n};\n\ntype GetMultipleSlotsResult<TSlotComponents extends FunctionalComponent[]> = {\n\tregularChildren: React.ReactNode[];\n\tslots: { [Key in keyof TSlotComponents]: ReturnType<TSlotComponents[Key]> };\n};\n\n/**\n * @description The same as getSingleSlot, but for multiple slot components\n */\nexport const getMultipleSlots = <const TSlotComponents extends FunctionalComponent[]>(\n\tchildren: React.ReactNode,\n\tSlotComponents: TSlotComponents,\n\toptions?: MultipleSlotsOptions\n): Prettify<GetMultipleSlotsResult<TSlotComponents>> => {\n\tconst { errorMessage, throwOnMultipleSlotMatch } = options ?? {};\n\n\tconst slots = SlotComponents.map((SlotComponent, index) =>\n\t\tgetSingleSlot(children, SlotComponent, {\n\t\t\terrorMessage: isArray(errorMessage) ? errorMessage[index] : errorMessage,\n\t\t\tthrowOnMultipleSlotMatch:\n\t\t\t\tisArray(throwOnMultipleSlotMatch) ? throwOnMultipleSlotMatch[index] : throwOnMultipleSlotMatch,\n\t\t})\n\t);\n\n\tconst regularChildren = getRegularChildren(children, SlotComponents);\n\n\treturn { regularChildren, slots } as GetMultipleSlotsResult<TSlotComponents>;\n};\n\n/**\n * @description Returns all children that are not slot elements (i.e., don't match any of the provided slot components)\n */\nexport const getRegularChildren = (\n\tchildren: React.ReactNode,\n\tSlotComponentOrComponents: FunctionalComponent | FunctionalComponent[]\n) => {\n\tconst actualChildren =\n\t\tisValidElement<InferProps<typeof ReactFragment>>(children) && children.type === ReactFragment ?\n\t\t\tchildren.props.children\n\t\t:\tchildren;\n\n\tconst childrenArray = toArray<React.ReactNode>(actualChildren);\n\n\tconst regularChildren = childrenArray.filter(\n\t\t(child) => !matchesAnySlotComponent(child, toArray(SlotComponentOrComponents))\n\t);\n\n\treturn regularChildren;\n};\n"],"mappings":";;;;;AAcA,MAAM,oBACL,cAC4D;AAC5D,QAAO,gBAAgB,aAAa,QAAQ,UAAU,WAAW;;AAGlE,MAAM,uBACL,cAC+D;AAC/D,QAAO,mBAAmB,aAAa,QAAQ,UAAU,cAAc;;;;;;;AAQxE,MAAa,wBAAwB,OAAwB,kBAAuC;AACnG,KAAI,CAAC,eAAe,MAAM,IAAI,CAAC,WAAW,MAAM,KAAK,CACpD,QAAO;CAGR,MAAM,oBACL,oBAAoB,MAAM,KAAK,GAAI,MAAM,KAAK,gBAAwC,MAAM;AAO7F,KAJC,iBAAiB,kBAAkB,IAChC,iBAAiB,cAAc,IAC/B,kBAAkB,eAAe,cAAc,WAGlD,QAAO;AAGR,KAAI,MAAM,KAAK,SAAS,cAAc,KACrC,QAAO;AAGR,QAAO;;;;;AAMR,MAAa,2BAA2B,OAAwB,mBAA0C;AAGzG,QAFoB,eAAe,MAAM,kBAAkB,qBAAqB,OAAO,cAAc,CAAC;;;;;;AAoBvG,MAAM,4BACL,eACA,kBACI;CACJ,IAAI,QAAQ;AAEZ,MAAK,MAAM,SAAS,eAAe;AAClC,MAAI,CAAC,qBAAqB,OAAO,cAAc,CAAE;AAEjD,WAAS;;AAGV,QAAO;;;;;;;AAQR,MAAa,iBACZ,UACA,eACA,UAAuB,EAAE,KACrB;CACJ,MAAM,EACL,eAAe,qDACf,2BAA2B,UACxB;CAEJ,MAAM,iBACL,eAAiD,SAAS,IAAI,SAAS,SAASA,WAC/E,SAAS,MAAM,WACd;CAEH,MAAM,gBAAgB,QAAyB,eAAe;AAK9D,KAFC,4BAA4B,yBAAyB,eAAe,cAAc,GAAG,EAGrF,OAAM,IAAI,eAAe,aAAa;AAKvC,QAFoB,cAAc,MAAM,UAAU,qBAAqB,OAAO,cAAc,CAAC;;;;;AA8B9F,MAAa,oBACZ,UACA,gBACA,YACuD;CACvD,MAAM,EAAE,cAAc,6BAA6B,WAAW,EAAE;CAEhE,MAAM,QAAQ,eAAe,KAAK,eAAe,UAChD,cAAc,UAAU,eAAe;EACtC,cAAc,QAAQ,aAAa,GAAG,aAAa,SAAS;EAC5D,0BACC,QAAQ,yBAAyB,GAAG,yBAAyB,SAAS;EACvE,CAAC,CACF;AAID,QAAO;EAAE,iBAFe,mBAAmB,UAAU,eAAe;EAE1C;EAAO;;;;;AAMlC,MAAa,sBACZ,UACA,8BACI;CACJ,MAAM,iBACL,eAAiD,SAAS,IAAI,SAAS,SAASA,WAC/E,SAAS,MAAM,WACd;AAQH,QANsB,QAAyB,eAAe,CAExB,QACpC,UAAU,CAAC,wBAAwB,OAAO,QAAQ,0BAA0B,CAAC,CAC9E"}