Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement →
Sign In

@asherng/hooks

Package Overview
Dependencies
Maintainers
1
Versions
27
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@asherng/hooks - npm Package Compare versions

Comparing version
0.1.10
 to
1.0.6
+32
-21
package.json
{
"name": "@asherng/hooks",
"version": "0.1.10",
"version": "1.0.6",
"description": "Hooks for React components",

@@ -18,15 +18,19 @@ "bugs": {

],
"main": "lib/index",
"types": "lib/index.d.ts",
"main": "dist/index",
"types": "dist/index.d.ts",
"files": [
"/*.d.ts",
"/*.js",
"hooks"
"dist"
],
"scripts": {
"build": "tsc -p tsconfig.build.json"
"dependencies": {
"@hookform/resolvers": "3.3.4",
"lodash.once": "4.1.1",
"react-fast-compare": "3.2.2",
"react-hook-form": "7.51.1",
"zod": "3.22.4",
"@asherng/utils": "^1.0.6"
},
"devDependencies": {
"@types/lodash.once": "4.1.7",
"typescript": "5.1.6"
"@types/lodash.once": "4.1.9",
"typescript": "5.4.3",
"@asherng/common-types": "^1.0.6"
},

@@ -36,14 +40,21 @@ "publishConfig": {

},
"exports": {
"./*": {
"types": "./dist/*/index.d.ts",
"require": "./dist/*/index.js",
"import": {
"types": "./dist/*/index.d.mts",
"default": "./dist/*/index.mjs"
}
}
},
"author": "Asher Nguyen <phucnguyenhoang1985@gmail.com>",
"license": "MIT",
"dependencies": {
"@asherng/common-types": "^0.1.3",
"@asherng/utils": "^0.1.7",
"@hookform/resolvers": "3.1.1",
"lodash.once": "4.1.1",
"react-fast-compare": "^3.2.2",
"react-hook-form": "7.45.1",
"yup": "1.2.0"
},
"gitHead": "5147f95a8849f7176622f3abd2874cfaa8b19568"
}
"gitHead": "c4702ddc44863e127b8f57ceee1141daecad5d35",
"scripts": {
"build": "tsup",
"build:fast": "pnpm build --no-splitting --shims",
"dev": "pnpm clean && pnpm build:fast --watch src",
"clean": "rimraf dist"
}
}
-3
hooks/useAsyncLoading/index.d.ts
import { UseAsyncLoading } from './types';
declare const useAsyncLoading: UseAsyncLoading;
export default useAsyncLoading;
-43
hooks/useAsyncLoading/index.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useStateIfMounted_1 = __importDefault(require("../useStateIfMounted"));
const useAsyncLoading = ({ func, onError, onSuccess }, deps) => {
const [loading, setLoading] = (0, useStateIfMounted_1.default)(false);
const [error, setError] = (0, useStateIfMounted_1.default)(undefined);
const wrappedFunc = (0, react_1.useCallback)((...args) => __awaiter(void 0, void 0, void 0, function* () {
if (!func) {
return;
}
setLoading(true);
let res;
try {
res = (yield (func === null || func === void 0 ? void 0 : func(...args)));
onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(res);
}
catch (e) {
setError(e);
onError === null || onError === void 0 ? void 0 : onError(e);
}
finally {
setLoading(false);
}
return res;
}),
// eslint-disable-next-line react-hooks/exhaustive-deps
deps !== null && deps !== void 0 ? deps : [func]);
return [wrappedFunc, loading, error];
};
exports.default = useAsyncLoading;
-8
hooks/useAsyncLoading/types.d.ts
import { DependencyList } from 'react';
import { AsyncFunction, GeneralFunction } from '@asherng/common-types';
export interface UseAsyncLoadingParams<F extends AsyncFunction | GeneralFunction = AsyncFunction | GeneralFunction> {
func?: F;
onSuccess?: (res?: Awaited<ReturnType<F>>) => void;
onError?: (err: Error) => void;
}
export type UseAsyncLoading = <F extends AsyncFunction | GeneralFunction = AsyncFunction | GeneralFunction>(params: UseAsyncLoadingParams<F>, deps?: DependencyList) => [F, boolean, Error | undefined];
-2
hooks/useAsyncLoading/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useClickOutside/index.d.ts
import { UseClickOutside } from './types';
declare const useClickOutside: UseClickOutside;
export default useClickOutside;
-29
hooks/useClickOutside/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useClickOutside = callback => {
const container = (0, react_1.useRef)(null);
const [isTouchEvent, setTouchEvent] = (0, react_1.useState)(false);
const eventType = isTouchEvent ? 'touchend' : 'click';
const handleEvent = (e) => {
if (e.type === 'click' && isTouchEvent) {
return;
}
if (container.current && e.target !== null) {
if (!container.current.contains(e.target)) {
callback(e);
}
}
};
(0, react_1.useEffect)(() => {
document.addEventListener(eventType, handleEvent, true);
return () => {
document.removeEventListener(eventType, handleEvent, true);
};
});
(0, react_1.useEffect)(() => {
setTouchEvent('ontouchstart' in document.documentElement);
}, []);
return container;
};
exports.default = useClickOutside;
-2
hooks/useClickOutside/types.d.ts
import { RefObject } from 'react';
export type UseClickOutside = (callback: EventListener) => RefObject<HTMLDivElement>;
-2
hooks/useClickOutside/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useDebounce/index.d.ts
import { UseDebounce } from './types';
declare const useDebounce: UseDebounce;
export default useDebounce;
-23
hooks/useDebounce/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useDebounceCallback_1 = __importDefault(require("../useDebounceCallback"));
const useDebounce = (value, delay, options) => {
var _a;
const compareValueDefault = (0, react_1.useCallback)((left, right) => left === right, []);
const compareValue = (_a = options === null || options === void 0 ? void 0 : options.compareValue) !== null && _a !== void 0 ? _a : compareValueDefault;
const [state, setState] = (0, react_1.useState)(value);
const [callback, cancel, callPending] = (0, useDebounceCallback_1.default)((0, react_1.useCallback)((currentValue) => setState(currentValue), []), delay, options);
const previousValue = (0, react_1.useRef)(value);
(0, react_1.useEffect)(() => {
if (!compareValue(previousValue.current, value)) {
callback(value);
previousValue.current = value;
}
}, [value, callback, compareValue]);
return [state, cancel, callPending];
};
exports.default = useDebounce;
-7
hooks/useDebounce/types.d.ts
import { GeneralFunction } from '@asherng/common-types';
import { UseDebounceBaseOptions } from '../useDebounceCallback/types';
export type CompareValue<T> = (left: T, right: T) => boolean;
export type UseDebounce = <T>(value: T, delay: number, option?: UseDebounceOptions<T>) => [T, GeneralFunction, GeneralFunction];
export interface UseDebounceOptions<T = string> extends UseDebounceBaseOptions {
compareValue?: CompareValue<T>;
}
-2
hooks/useDebounce/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useDebounceCallback/index.d.ts
import { UseDebouncedCallback } from './types';
declare const useDebouncedCallback: UseDebouncedCallback;
export default useDebouncedCallback;
-65
hooks/useDebounceCallback/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useDebouncedCallback = (callback, delay, options) => {
var _a;
const maxWaitHandler = (0, react_1.useRef)(undefined);
const leading = options === null || options === void 0 ? void 0 : options.leading;
const trailing = (_a = options === null || options === void 0 ? void 0 : options.trailing) !== null && _a !== void 0 ? _a : true;
const maxWait = options === null || options === void 0 ? void 0 : options.maxWait;
const maxWaitArgs = (0, react_1.useRef)([]);
const leadingCall = (0, react_1.useRef)(false);
const functionTimeoutHandler = (0, react_1.useRef)(undefined);
const isComponentUnmounted = (0, react_1.useRef)(false);
const debouncedFunction = (0, react_1.useRef)(callback);
const cancelDebouncedCallback = (0, react_1.useCallback)(() => {
clearTimeout(functionTimeoutHandler.current);
clearTimeout(maxWaitHandler.current);
maxWaitHandler.current = undefined;
maxWaitArgs.current = [];
functionTimeoutHandler.current = undefined;
leadingCall.current = false;
}, []);
(0, react_1.useEffect)(() => () => {
isComponentUnmounted.current = true;
}, []);
const debouncedCallback = (0, react_1.useCallback)((...args) => {
maxWaitArgs.current = args;
clearTimeout(functionTimeoutHandler.current);
if (leadingCall.current) {
leadingCall.current = false;
}
if (!functionTimeoutHandler.current && leading && !leadingCall.current) {
debouncedFunction.current(...args);
leadingCall.current = true;
}
functionTimeoutHandler.current = window.setTimeout(() => {
let shouldCallFunction = true;
if (leading && leadingCall.current) {
shouldCallFunction = false;
}
cancelDebouncedCallback();
if (!isComponentUnmounted.current && trailing && shouldCallFunction) {
debouncedFunction.current(...args);
}
}, delay);
if (maxWait && !maxWaitHandler.current && trailing) {
maxWaitHandler.current = window.setTimeout(() => {
const callbackArgs = maxWaitArgs.current;
cancelDebouncedCallback();
if (!isComponentUnmounted.current) {
debouncedFunction.current.apply(null, callbackArgs);
}
}, maxWait);
}
}, [maxWait, delay, cancelDebouncedCallback, leading, trailing]);
const callPending = (0, react_1.useCallback)(() => {
if (!functionTimeoutHandler.current) {
return;
}
debouncedFunction.current.apply(null, maxWaitArgs.current);
cancelDebouncedCallback();
}, [cancelDebouncedCallback]);
return [debouncedCallback, cancelDebouncedCallback, callPending];
};
exports.default = useDebouncedCallback;
-10
hooks/useDebounceCallback/types.d.ts
import { GeneralFunction } from '@asherng/common-types';
export type SetTimeOutType = number | undefined;
export interface UseDebounceBaseOptions {
maxWait?: number;
leading?: boolean;
trailing?: boolean;
}
export interface UseDebouncedCallbackOptions extends UseDebounceBaseOptions {
}
export type UseDebouncedCallback = <T extends GeneralFunction>(callback: T, delay: number, options?: UseDebouncedCallbackOptions) => [T, GeneralFunction, GeneralFunction];
-2
hooks/useDebounceCallback/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useEnhancedEffect/index.d.ts
import { UseEnhancedEffect } from './types';
declare const useEnhancedEffect: UseEnhancedEffect;
export default useEnhancedEffect;
-5
hooks/useEnhancedEffect/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useEnhancedEffect = typeof window === 'undefined' ? react_1.useEffect : react_1.useLayoutEffect;
exports.default = useEnhancedEffect;
-2
hooks/useEnhancedEffect/types.d.ts
import { EffectCallback, DependencyList } from 'react';
export type UseEnhancedEffect = (effect: EffectCallback, deps?: DependencyList) => void;
-2
hooks/useEnhancedEffect/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useEventListener/index.d.ts
import { UseEventListener } from './types';
declare const useEventListener: UseEventListener;
export default useEventListener;
-21
hooks/useEventListener/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useEventListener = (eventName, handler, element = window) => {
const savedHandler = (0, react_1.useRef)();
(0, react_1.useEffect)(() => {
savedHandler.current = handler;
}, [handler]);
(0, react_1.useEffect)(() => {
const isSupported = element && element.addEventListener;
if (!isSupported) {
return;
}
const eventListener = (event) => { var _a; return (_a = savedHandler === null || savedHandler === void 0 ? void 0 : savedHandler.current) === null || _a === void 0 ? void 0 : _a.call(savedHandler, event); };
element.addEventListener(eventName, eventListener);
return () => {
element.removeEventListener(eventName, eventListener);
};
}, [eventName, element]);
};
exports.default = useEventListener;
-2
hooks/useEventListener/types.d.ts
import { GeneralFunction } from '@asherng/common-types';
export type UseEventListener = (eventName: string, handler: GeneralFunction, element?: Element | (Window & typeof globalThis)) => void;
-2
hooks/useEventListener/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useForkRef/index.d.ts
import { UseForkRef } from './types';
declare const useForkRef: UseForkRef;
export default useForkRef;
-17
hooks/useForkRef/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const setRef_1 = __importDefault(require("@asherng/utils/setRef"));
const useForkRef = (refA, refB) => (0, react_1.useMemo)(() => {
if (refA == null && refB == null) {
return null;
}
return refValue => {
(0, setRef_1.default)(refA, refValue);
(0, setRef_1.default)(refB, refValue);
};
}, [refA, refB]);
exports.default = useForkRef;
-2
hooks/useForkRef/types.d.ts
import { Nullable, RefType } from '@asherng/common-types';
export type UseForkRef = <T>(refA: RefType<T>, refB: RefType<T>) => Nullable<(v: T) => void>;
-2
hooks/useForkRef/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useForm/index.d.ts
import { UseFormParams, UseFormResponse } from './types';
declare const useForm: <T extends import("react-hook-form").FieldValues = import("react-hook-form").FieldValues>(options: UseFormParams<T>) => UseFormResponse<T>;
export default useForm;
-42
hooks/useForm/index.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const yup_1 = require("@hookform/resolvers/yup");
const react_hook_form_1 = require("react-hook-form");
const useForm = (options) => {
const { onSubmit, nativeSubmit, resetOnSubmit, resolver, resetValues, omitResetState, defaultValues, mode, context, criteriaMode, shouldFocusError, shouldUnregister, reValidateMode = 'onChange' } = options;
const customResolver = resolver ? (0, yup_1.yupResolver)(resolver) : undefined;
const formMethods = (0, react_hook_form_1.useForm)({
defaultValues,
mode,
context,
criteriaMode,
shouldFocusError,
shouldUnregister,
reValidateMode,
resolver: customResolver
});
const customSubmit = (data, e) => __awaiter(void 0, void 0, void 0, function* () {
e === null || e === void 0 ? void 0 : e.preventDefault();
if (resetOnSubmit && !!formMethods.formState.errors) {
formMethods.reset(resetValues, omitResetState);
}
if (onSubmit) {
yield onSubmit(data, formMethods, e);
}
else if (nativeSubmit) {
nativeSubmit(data, e);
}
});
const onSubmitHandler = formMethods.handleSubmit(customSubmit);
return Object.assign(Object.assign({}, formMethods), { onSubmit: onSubmitHandler });
};
exports.default = useForm;
-35
hooks/useForm/types.d.ts
import { AsyncFunction, GeneralFunction } from '@asherng/common-types';
import { BaseSyntheticEvent } from 'react';
import { DeepMap, DeepPartial, FieldError as DefaultFieldError, FieldValue as DefaultFieldValue, FieldValues as DefaultFieldValues, KeepStateOptions, Path, SubmitHandler, UseFormProps, UseFormReturn } from 'react-hook-form';
import { Asserts, ISchema, ObjectSchema } from 'yup';
export type OnSubmitData<T extends FieldValues = FieldValues> = T;
export type Resolver = ObjectSchema<any>;
export type FormData<T extends ISchema<any, any>> = Asserts<T>;
export type OnSubmitHandler<T extends FieldValues = FieldValues> = GeneralFunction<[
data: OnSubmitData<T>,
formMethods?: UseFormReturn<T>,
event?: BaseSyntheticEvent
]> | AsyncFunction<[
data: OnSubmitData<T>,
formMethods?: UseFormReturn<T>,
event?: BaseSyntheticEvent
]>;
export type OnSubmit = AsyncFunction<[e?: BaseSyntheticEvent]>;
export interface UseFormParams<T extends FieldValues = FieldValues> extends Omit<UseFormProps<T>, 'resolver'> {
nativeSubmit?: SubmitHandler<T>;
onSubmit?: OnSubmitHandler<T>;
resetOnSubmit?: boolean;
resetValues?: DeepPartial<T>;
omitResetState?: KeepStateOptions;
enableReinitialize?: boolean;
triggerValidationImmediately?: boolean;
defaultValues?: DeepPartial<T>;
resolver?: Resolver;
}
export interface UseFormResponse<T extends FieldValues = FieldValues> extends UseFormReturn<T> {
onSubmit?: OnSubmit;
}
export type FieldValues = DefaultFieldValues;
export type FieldName<T extends FieldValues = FieldValues> = Path<T>;
export type FieldValue<T extends FieldValues = FieldValues> = DefaultFieldValue<T>;
export type FieldError<T extends FieldValues = FieldValues> = NonNullable<DeepMap<T, DefaultFieldError>>[FieldName<T>] | undefined;
-2
hooks/useForm/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useForm/utils.d.ts
/// <reference types="react" />
import { UseFormResponse } from './types';
export declare const createFormContext: <T extends import("react-hook-form").FieldValues = import("react-hook-form").FieldValues>() => import("react").Context<UseFormResponse<T>>;
-9
hooks/useForm/utils.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFormContext = void 0;
const react_1 = require("react");
const lodash_once_1 = __importDefault(require("lodash.once"));
exports.createFormContext = (0, lodash_once_1.default)(() => (0, react_1.createContext)({}));
-3
hooks/useFormMethods/index.d.ts
import { UseFormResponse } from '../useForm/types';
declare const useFormMethods: <T extends import("react-hook-form").FieldValues = import("react-hook-form").FieldValues>() => UseFormResponse<T>;
export default useFormMethods;
-9
hooks/useFormMethods/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const utils_1 = require("../useForm/utils");
const useFormMethods = () => {
const FormContext = (0, utils_1.createFormContext)();
return (0, react_1.useContext)(FormContext);
};
exports.default = useFormMethods;
-3
hooks/useFormMethods/types.d.ts
import { FieldValues, UseFormResponse } from '../useForm/types';
export type UseFormMethods = <T extends FieldValues = FieldValues>() => UseFormResponse<T>;
export type FormMethods<T extends FieldValues = FieldValues> = UseFormResponse<T>;
-2
hooks/useFormMethods/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useInterval/index.d.ts
import { UseInterval } from './types';
declare const useInterval: UseInterval;
export default useInterval;
-21
hooks/useInterval/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useEnhancedEffect_1 = __importDefault(require("../useEnhancedEffect"));
const useInterval = (callback, delay = 0) => {
const savedCallback = (0, react_1.useRef)(callback);
(0, useEnhancedEffect_1.default)(() => {
savedCallback.current = callback;
}, [callback]);
(0, react_1.useEffect)(() => {
if (!delay && delay !== 0) {
return;
}
const id = setInterval(() => savedCallback.current(), delay);
return () => clearInterval(id);
}, [delay]);
};
exports.default = useInterval;
-2
hooks/useInterval/types.d.ts
import { GeneralFunction } from '@asherng/common-types';
export type UseInterval = (callback: GeneralFunction, delay?: number) => void;
-2
hooks/useInterval/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useInView/index.d.ts
import { UseInView } from './types';
declare const useInView: UseInView;
export default useInView;
-71
hooks/useInView/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useEnhancedEffect_1 = __importDefault(require("../useEnhancedEffect"));
const usePrevious_1 = __importDefault(require("../usePrevious"));
const utils_1 = require("./utils");
const useInView = ({ threshold, delay, trackVisibility, rootMargin, root, triggerOnce, skip, initialInView, fallbackInView, onChange } = {}) => {
var _a, _b;
const ref = (0, react_1.useRef)(null);
const [state, setState] = (0, react_1.useState)({
inView: !!initialInView,
entry: undefined
});
(0, useEnhancedEffect_1.default)(() => {
if (skip || !ref.current) {
return;
}
let unobserve;
unobserve = (0, utils_1.observe)(ref.current, (inView, entry) => {
setState({
inView,
entry
});
onChange === null || onChange === void 0 ? void 0 : onChange(inView, entry);
if (entry.isIntersecting && triggerOnce && unobserve) {
unobserve();
unobserve = undefined;
}
}, {
root,
rootMargin,
threshold,
trackVisibility,
delay
}, fallbackInView);
return () => {
if (unobserve) {
unobserve();
}
};
}, [
Array.isArray(threshold) ? threshold.toString() : threshold,
ref,
root,
rootMargin,
triggerOnce,
skip,
trackVisibility,
fallbackInView,
delay
]);
const entryTarget = (_a = state.entry) === null || _a === void 0 ? void 0 : _a.target;
const previousEntryTarget = (0, usePrevious_1.default)((_b = state.entry) === null || _b === void 0 ? void 0 : _b.target);
(0, react_1.useEffect)(() => {
if (!ref && entryTarget && !triggerOnce && !skip && previousEntryTarget !== entryTarget) {
setState({
inView: !!initialInView,
entry: undefined
});
}
}, [initialInView, triggerOnce, skip, entryTarget, previousEntryTarget]);
return {
ref,
inView: state.inView,
entry: state.entry
};
};
exports.default = useInView;
-35
hooks/useInView/types.d.ts
import { Nullable } from '@asherng/common-types';
import { RefObject } from 'react';
export interface UseInViewParams<E extends Element> extends IntersectionObserverInit {
/** The IntersectionObserver interface's read-only `root` property identifies the Element or Document whose bounds are treated as the bounding box of the viewport for the element which is the observer's target. If the `root` is null, then the bounds of the actual document viewport are used.*/
root?: Nullable<E>;
/** Margin around the root. Can have values similar to the CSS margin property, e.g. `10px 20px 30px 40px` (top, right, bottom, left). */
rootMargin?: string;
/** Number between `0` and `1` indicating the percentage that should be visible before triggering. Can also be an `array` of numbers, to create multiple trigger points. */
threshold?: number | number[];
/** Only trigger the inView callback once */
triggerOnce?: boolean;
/** Skip assigning the observer to the `ref` */
skip?: boolean;
/** Set the initial value of the `inView` boolean. This can be used if you expect the element to be in the viewport to start with, and you want to trigger something when it leaves. */
initialInView?: boolean;
/** Fallback to this inView state if the IntersectionObserver is unsupported, and a polyfill wasn't loaded */
fallbackInView?: boolean;
/** IntersectionObserver v2 - Track the actual visibility of the element */
trackVisibility?: boolean;
/** IntersectionObserver v2 - Set a minimum delay between notifications */
delay?: number;
/** Call this function whenever the in view state changes */
onChange?: (inView: boolean, entry: IntersectionObserverEntry) => void;
}
export interface UseInViewResponse<E extends Element> {
ref: RefObject<E>;
inView: boolean;
entry?: IntersectionObserverEntry;
}
export type UseInView = <E extends Element>(params?: UseInViewParams<E>) => UseInViewResponse<E>;
export interface UseInViewState {
inView: boolean;
entry?: IntersectionObserverEntry;
}
export type ObserverInstanceCallback = (inView: boolean, entry: IntersectionObserverEntry) => void;
-2
hooks/useInView/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-5
hooks/useInView/utils.d.ts
import { GeneralFunction } from '@asherng/common-types';
import type { ObserverInstanceCallback } from './types';
export declare const defaultFallbackInView: (inView: boolean | undefined) => void;
export declare const optionsToId: (options: IntersectionObserverInit) => string;
export declare const observe: <E extends Element>(element: E, callback: ObserverInstanceCallback, options?: IntersectionObserverInit, fallbackInView?: boolean | undefined) => GeneralFunction;
-99
hooks/useInView/utils.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.observe = exports.optionsToId = exports.defaultFallbackInView = void 0;
const observerMap = new Map();
const RootIds = new WeakMap();
let rootId = 0;
let unsupportedValue = undefined;
const defaultFallbackInView = (inView) => {
unsupportedValue = inView;
};
exports.defaultFallbackInView = defaultFallbackInView;
const getRootId = (root) => {
if (!root) {
return '0';
}
if (RootIds.has(root)) {
return RootIds.get(root);
}
rootId += 1;
RootIds.set(root, rootId.toString());
return RootIds.get(root);
};
const optionsToId = (options) => Object.keys(options)
.sort()
.filter(key => options[key] !== undefined)
.map(key => {
return `${key}_${key === 'root' ? getRootId(options.root) : options[key]}`;
})
.toString();
exports.optionsToId = optionsToId;
const createObserver = (options) => {
const id = (0, exports.optionsToId)(options);
let instance = observerMap.get(id);
if (!instance) {
const elements = new Map();
let thresholds = [];
const observer = new IntersectionObserver(entries => {
entries.forEach(entry => {
var _a;
const inView = entry.isIntersecting &&
thresholds.some(threshold => entry.intersectionRatio >= threshold);
if (options.trackVisibility && typeof entry.isVisible === 'undefined') {
entry.isVisible = inView;
}
(_a = elements.get(entry.target)) === null || _a === void 0 ? void 0 : _a.forEach(callback => {
callback(inView, entry);
});
});
}, options);
thresholds =
observer.thresholds ||
(Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
instance = {
id,
observer,
elements
};
observerMap.set(id, instance);
}
return instance;
};
const observe = (element, callback, options = {}, fallbackInView = unsupportedValue) => {
if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {
const bounds = element.getBoundingClientRect();
callback(fallbackInView, {
isIntersecting: fallbackInView,
target: element,
intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,
time: 0,
boundingClientRect: bounds,
intersectionRect: bounds,
rootBounds: bounds
});
return () => undefined;
}
// An observer with the same options can be reused, so lets use this fact
const { id, observer, elements } = createObserver(options);
// Register the callback listener for this element
const callbacks = elements.get(element) || [];
if (!elements.has(element)) {
elements.set(element, callbacks);
}
callbacks.push(callback);
observer.observe(element);
return () => {
// Remove the callback from the callback list
callbacks.splice(callbacks.indexOf(callback), 1);
if (callbacks.length === 0) {
// No more callback exists for element, so destroy it
elements.delete(element);
observer.unobserve(element);
}
if (elements.size === 0) {
observer.disconnect();
observerMap.delete(id);
}
};
};
exports.observe = observe;
-8
hooks/useIsComponentMounted/index.d.ts
import { UseIsComponentMounted } from './types';
/**
* Check if component is mounted or not.
*
* @returns Boolean
*/
declare const useIsComponentMounted: UseIsComponentMounted;
export default useIsComponentMounted;
-19
hooks/useIsComponentMounted/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
/**
* Check if component is mounted or not.
*
* @returns Boolean
*/
const useIsComponentMounted = () => {
const isMounted = (0, react_1.useRef)(false);
(0, react_1.useEffect)(() => {
isMounted.current = true;
return () => {
isMounted.current = false;
};
}, []);
return isMounted;
};
exports.default = useIsComponentMounted;
-3
hooks/useIsComponentMounted/types.d.ts
import { GeneralFunction } from '@asherng/common-types';
import { MutableRefObject } from 'react';
export type UseIsComponentMounted = GeneralFunction<[], MutableRefObject<boolean>>;
-2
hooks/useIsComponentMounted/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useIsFirstRender/index.d.ts
import { UseIsFirstRender } from './types';
declare const useIsFirstRender: UseIsFirstRender;
export default useIsFirstRender;
-15
hooks/useIsFirstRender/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useEnhancedEffect_1 = __importDefault(require("../useEnhancedEffect"));
const useIsFirstRender = () => {
const isFirstRender = (0, react_1.useRef)(true);
(0, useEnhancedEffect_1.default)(() => {
isFirstRender.current = false;
}, []);
return isFirstRender.current;
};
exports.default = useIsFirstRender;
-1
hooks/useIsFirstRender/types.d.ts
export type UseIsFirstRender = () => boolean;
-2
hooks/useIsFirstRender/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/usePrevious/index.d.ts
import { UsePrevious } from './types';
declare const usePrevious: UsePrevious;
export default usePrevious;
-11
hooks/usePrevious/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const usePrevious = value => {
const ref = (0, react_1.useRef)();
(0, react_1.useEffect)(() => {
ref.current = value;
}, [value]);
return ref.current;
};
exports.default = usePrevious;
-1
hooks/usePrevious/types.d.ts
export type UsePrevious = <T>(value: T) => T | undefined;
-2
hooks/usePrevious/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useResponsive/index.d.ts
import { BaseConfig, UseResponsiveResponse, UseResponsiveParams } from './types';
declare const useResponsive: <C extends BaseConfig, D extends keyof C | undefined>({ config, defaultBreakpoint }: UseResponsiveParams<C, D>) => UseResponsiveResponse<C, D>;
export default useResponsive;
-55
hooks/useResponsive/index.js
"use strict";
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useEnhancedEffect_1 = __importDefault(require("../useEnhancedEffect"));
const utils_1 = require("./utils");
const useResponsive = ({ config, defaultBreakpoint }) => {
const mediaQueries = (0, react_1.useMemo)(() => (0, utils_1.createMediaQueries)(config), [config]);
const [currentBreakpoint, setCurrentBreakpoint] = (0, react_1.useState)((0, utils_1.getCurrentBreakPoint)(mediaQueries, defaultBreakpoint));
const updateBreakpoint = (0, react_1.useCallback)(({ matches }, breakpoint) => {
if (matches) {
setCurrentBreakpoint(breakpoint);
}
}, []);
(0, useEnhancedEffect_1.default)(() => {
const unsubscribers = mediaQueries.map((_a) => {
var { query } = _a, breakpoint = __rest(_a, ["query"]);
const mediaQuery = window.matchMedia(query);
updateBreakpoint(mediaQuery, breakpoint);
const handleChange = (event) => {
updateBreakpoint(event, breakpoint);
};
if (mediaQuery === null || mediaQuery === void 0 ? void 0 : mediaQuery.addEventListener) {
mediaQuery.addEventListener('change', handleChange);
}
else if (mediaQuery === null || mediaQuery === void 0 ? void 0 : mediaQuery.addListener) {
mediaQuery.addListener(handleChange);
}
return () => {
if (mediaQuery === null || mediaQuery === void 0 ? void 0 : mediaQuery.removeEventListener) {
mediaQuery.removeEventListener('change', handleChange);
}
else if (mediaQuery === null || mediaQuery === void 0 ? void 0 : mediaQuery.removeListener) {
mediaQuery.removeListener(handleChange);
}
};
});
return () => unsubscribers.forEach(unsubscriber => unsubscriber());
}, [mediaQueries, updateBreakpoint]);
return currentBreakpoint;
};
exports.default = useResponsive;
-26
hooks/useResponsive/types.d.ts
export interface BaseConfig {
[key: string]: number;
}
export interface Breakpoint<C extends BaseConfig = BaseConfig> {
breakpoint: keyof C;
maxWidth?: number | null;
minWidth: C[keyof C];
}
export interface MediaQuery<C extends BaseConfig = BaseConfig> {
breakpoint: keyof C;
maxWidth: number | null;
minWidth: C[keyof C];
query: string;
}
export type GetCurrentBreakPoint = <C extends BaseConfig, D extends keyof C | undefined>(mediaQueries: MediaQuery<C>[], defaultBreakpoint: D) => Breakpoint<C> | EmptyBreakpoint;
export type CreateMediaQueries = <C extends BaseConfig = BaseConfig>(breakpoints: C) => MediaQuery<C>[];
export interface EmptyBreakpoint {
breakpoint: undefined;
minWidth: undefined;
maxWidth: undefined;
}
export interface UseResponsiveParams<C extends BaseConfig, D extends keyof C | undefined> {
config: C;
defaultBreakpoint?: D;
}
export type UseResponsiveResponse<C extends BaseConfig, D extends keyof C | undefined> = D extends undefined ? Breakpoint<C> | EmptyBreakpoint : D extends keyof C ? Breakpoint<C> : never;
-2
hooks/useResponsive/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-4
hooks/useResponsive/utils.d.ts
import type { CreateMediaQueries, GetCurrentBreakPoint, EmptyBreakpoint } from './types';
export declare const EMPTY_BREAKPOINT: EmptyBreakpoint;
export declare const createMediaQueries: CreateMediaQueries;
export declare const getCurrentBreakPoint: GetCurrentBreakPoint;
-61
hooks/useResponsive/utils.js
"use strict";
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getCurrentBreakPoint = exports.createMediaQueries = exports.EMPTY_BREAKPOINT = void 0;
exports.EMPTY_BREAKPOINT = {
breakpoint: undefined,
minWidth: undefined,
maxWidth: undefined
};
const createMediaQueries = breakpoints => {
const sortedBreakpoints = Object.keys(breakpoints).sort((a, b) => breakpoints[b] - breakpoints[a]);
return sortedBreakpoints.map((breakpoint, index) => {
let query = '';
const minWidth = breakpoints[breakpoint];
const nextBreakpoint = sortedBreakpoints[index - 1];
const maxWidth = nextBreakpoint ? breakpoints[nextBreakpoint] : null;
if (minWidth >= 0) {
query = `(min-width: ${minWidth}px)`;
}
if (maxWidth !== null) {
if (query) {
query += ' and ';
}
query += `(max-width: ${maxWidth - 1}px)`;
}
const mediaQuery = {
breakpoint,
maxWidth: maxWidth ? maxWidth - 1 : null,
minWidth,
query
};
return mediaQuery;
});
};
exports.createMediaQueries = createMediaQueries;
const getCurrentBreakPoint = (mediaQueries, defaultBreakpoint) => {
for (let _a of mediaQueries) {
const { query } = _a, breakpoint = __rest(_a, ["query"]);
if (typeof window !== 'undefined' && !defaultBreakpoint) {
const mediaQuery = window.matchMedia(query);
if (mediaQuery.matches) {
return breakpoint;
}
}
else if (breakpoint.breakpoint === defaultBreakpoint) {
return breakpoint;
}
}
return exports.EMPTY_BREAKPOINT;
};
exports.getCurrentBreakPoint = getCurrentBreakPoint;
-3
hooks/useScript/index.d.ts
import { UseScript } from './types';
declare const useScript: UseScript;
export default useScript;
-51
hooks/useScript/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const cachedScripts = [];
const useScript = src => {
const [state, setState] = (0, react_1.useState)({
loaded: false,
error: false
});
(0, react_1.useEffect)(() => {
if (cachedScripts.includes(src)) {
setState({
loaded: true,
error: false
});
return;
}
else {
cachedScripts.push(src);
const script = document.createElement('script');
script.src = src;
script.async = true;
const onScriptLoad = () => {
setState({
loaded: true,
error: false
});
};
const onScriptError = () => {
const scriptIndex = cachedScripts.indexOf(src);
if (scriptIndex !== -1) {
cachedScripts.splice(scriptIndex, 1);
}
script.remove();
setState({
loaded: false,
error: true
});
};
script.addEventListener('load', onScriptLoad);
script.addEventListener('error', onScriptError);
document.body.appendChild(script);
return () => {
script.removeEventListener('load', onScriptLoad);
script.removeEventListener('error', onScriptError);
};
}
}, [src]);
return [state.loaded, state.error];
};
exports.default = useScript;
-1
hooks/useScript/types.d.ts
export type UseScript = (src: string) => boolean[];
-2
hooks/useScript/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useStableMemo/index.d.ts
import { DependencyList } from 'react';
declare const useStableMemo: <T>(factory: () => T, deps?: DependencyList) => T;
export default useStableMemo;
-24
hooks/useStableMemo/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const react_fast_compare_1 = __importDefault(require("react-fast-compare"));
const useStableMemo = (factory, deps) => {
let isValid = true;
const valueRef = (0, react_1.useRef)();
if (!valueRef.current) {
valueRef.current = {
deps,
result: factory()
};
}
else {
isValid = !!(deps && valueRef.current.deps && (0, react_fast_compare_1.default)(deps, valueRef.current.deps));
}
const cache = isValid ? valueRef.current : { deps, result: factory() };
valueRef.current = cache;
return cache.result;
};
exports.default = useStableMemo;
-5
hooks/useStableMemo/types.d.ts
import { DependencyList } from 'react';
export interface DepsCache<T> {
deps?: DependencyList;
result: T;
}
-2
hooks/useStableMemo/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useStateController/index.d.ts
import { UseStateControllerParams, UseStateControllerResponse } from './types';
declare const useStateController: <T>({ value: valueProp, defaultValue, onChange, shouldUpdate }: UseStateControllerParams<T>) => UseStateControllerResponse<T>;
export default useStateController;
-24
hooks/useStateController/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useStateIfMounted_1 = __importDefault(require("../useStateIfMounted"));
const useStateController = ({ value: valueProp, defaultValue, onChange, shouldUpdate = (prev, next) => prev !== next }) => {
const [valueState, setValue] = (0, useStateIfMounted_1.default)(defaultValue);
const isControlled = valueProp !== undefined;
const value = (0, react_1.useMemo)(() => (isControlled ? valueProp : valueState), [valueState, valueProp, isControlled]);
const updateValue = (0, react_1.useCallback)((next) => {
const nextValue = (typeof next === 'function' ? next(value) : next);
if (!shouldUpdate(value, nextValue)) {
return;
}
if (!isControlled) {
setValue(nextValue);
}
onChange === null || onChange === void 0 ? void 0 : onChange(nextValue);
}, [value, shouldUpdate, isControlled, onChange]);
return [value, updateValue];
};
exports.default = useStateController;
-10
hooks/useStateController/types.d.ts
import { Dispatch, SetStateAction } from 'react';
export type StateSelfUpdater<T> = (prevState: T) => T;
export type OnStateChangeHandler<T> = (value: T, ...args: any[]) => void;
export interface UseStateControllerParams<T> {
value?: T;
defaultValue?: T;
onChange?: OnStateChangeHandler<T>;
shouldUpdate?: (prev: T, next: T) => boolean;
}
export type UseStateControllerResponse<T> = [T, Dispatch<SetStateAction<T>>];
-2
hooks/useStateController/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-13
hooks/useStateIfMounted/index.d.ts
import { UseStateIfMountedParamResponse, UseStateIfMountedParams } from './types';
/**
* Like React's [useState](https://reactjs.org/docs/hooks-reference.html#usestate)
* but it makes sure the component that uses this hook is mounted when updating state
*
* @param {any} initialValue
* @returns {[any, Diapatch<any>]} an array of 2 items
*
* the first is the current state, the second is a function that enables
* updating the state if the component is not mounted
*/
declare const useStateIfMounted: <S>(initialValue?: UseStateIfMountedParams<S> | undefined) => UseStateIfMountedParamResponse<S>;
export default useStateIfMounted;
-28
hooks/useStateIfMounted/index.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useIsComponentMounted_1 = __importDefault(require("../useIsComponentMounted"));
/**
* Like React's [useState](https://reactjs.org/docs/hooks-reference.html#usestate)
* but it makes sure the component that uses this hook is mounted when updating state
*
* @param {any} initialValue
* @returns {[any, Diapatch<any>]} an array of 2 items
*
* the first is the current state, the second is a function that enables
* updating the state if the component is not mounted
*/
const useStateIfMounted = (initialValue) => {
const isComponentMounted = (0, useIsComponentMounted_1.default)();
const [state, setState] = (0, react_1.useState)(initialValue);
const newSetState = value => {
if (isComponentMounted.current) {
setState(value);
}
};
return [state, newSetState];
};
exports.default = useStateIfMounted;
-3
hooks/useStateIfMounted/types.d.ts
import { Dispatch, SetStateAction } from 'react';
export type UseStateIfMountedParams<S = undefined> = S | (() => S);
export type UseStateIfMountedParamResponse<S = undefined> = [S, Dispatch<SetStateAction<S>>];
-2
hooks/useStateIfMounted/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-3
hooks/useUnmountEffect/index.d.ts
import { UseUnmountEffect } from './types';
declare const useUnmountEffect: UseUnmountEffect;
export default useUnmountEffect;
-7
hooks/useUnmountEffect/index.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const react_1 = require("react");
const useUnmountEffect = (callback, deps = []) => (0, react_1.useEffect)(() => () => callback(),
// eslint-disable-next-line react-hooks/exhaustive-deps
deps);
exports.default = useUnmountEffect;
-3
hooks/useUnmountEffect/types.d.ts
import { DependencyList } from 'react';
import { GeneralFunction } from '@asherng/common-types';
export type UseUnmountEffect = (effect: GeneralFunction<[]>, deps?: DependencyList) => void;
-2
hooks/useUnmountEffect/types.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-2
useAsyncLoading.d.ts
export { default } from './hooks/useAsyncLoading';
export type { UseAsyncLoading } from './hooks/useAsyncLoading/types';
-8
useAsyncLoading.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useAsyncLoading_1 = require("./hooks/useAsyncLoading");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useAsyncLoading_1).default; } });
-2
useClickOutside.d.ts
export { default } from './hooks/useClickOutside';
export { UseClickOutside } from './hooks/useClickOutside/types';
-8
useClickOutside.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useClickOutside_1 = require("./hooks/useClickOutside");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useClickOutside_1).default; } });
-2
useDebounce.d.ts
export { default } from './hooks/useDebounce';
export { UseDebounce, UseDebounceOptions } from './hooks/useDebounce/types';
-8
useDebounce.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useDebounce_1 = require("./hooks/useDebounce");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useDebounce_1).default; } });
-2
useDebouncedCallback.d.ts
export { default } from './hooks/useDebounceCallback';
export { UseDebounceBaseOptions, UseDebouncedCallback, UseDebouncedCallbackOptions } from './hooks/useDebounceCallback/types';
-8
useDebouncedCallback.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useDebounceCallback_1 = require("./hooks/useDebounceCallback");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useDebounceCallback_1).default; } });
-2
useEnhancedEffect.d.ts
export { default } from './hooks/useEnhancedEffect';
export { UseEnhancedEffect } from './hooks/useEnhancedEffect/types';
-8
useEnhancedEffect.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useEnhancedEffect_1 = require("./hooks/useEnhancedEffect");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useEnhancedEffect_1).default; } });
-2
useEventListener.d.ts
export { default } from './hooks/useEventListener';
export { UseEventListener } from './hooks/useEventListener/types';
-8
useEventListener.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useEventListener_1 = require("./hooks/useEventListener");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useEventListener_1).default; } });
-2
useForkRef.d.ts
export { default } from './hooks/useForkRef';
export { UseForkRef } from './hooks/useForkRef/types';
-8
useForkRef.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useForkRef_1 = require("./hooks/useForkRef");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useForkRef_1).default; } });
-3
useForm.d.ts
export { default } from './hooks/useForm';
export type { UseFormResponse, UseFormParams, OnSubmitHandler, OnSubmitData, Resolver, FieldValues, FieldError, FieldName, FieldValue, FormData } from './hooks/useForm/types';
export { createFormContext } from './hooks/useForm/utils';
-10
useForm.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFormContext = exports.default = void 0;
var useForm_1 = require("./hooks/useForm");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useForm_1).default; } });
var utils_1 = require("./hooks/useForm/utils");
Object.defineProperty(exports, "createFormContext", { enumerable: true, get: function () { return utils_1.createFormContext; } });
-2
useFormMethods.d.ts
export { default } from './hooks/useFormMethods';
export { UseFormMethods, FormMethods } from './hooks/useFormMethods/types';
-8
useFormMethods.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useFormMethods_1 = require("./hooks/useFormMethods");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useFormMethods_1).default; } });
-2
useInterval.d.ts
export { default } from './hooks/useInterval';
export * from './hooks/useInterval/types';
-23
useInterval.js
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useInterval_1 = require("./hooks/useInterval");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useInterval_1).default; } });
__exportStar(require("./hooks/useInterval/types"), exports);
-3
useInView.d.ts
export { default } from './hooks/useInView';
export * from './hooks/useInView/utils';
export * from './hooks/useInView/types';
-24
useInView.js
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useInView_1 = require("./hooks/useInView");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useInView_1).default; } });
__exportStar(require("./hooks/useInView/utils"), exports);
__exportStar(require("./hooks/useInView/types"), exports);
-2
useIsComponentMounted.d.ts
export { default } from './hooks/useIsComponentMounted';
export type { UseIsComponentMounted } from './hooks/useIsComponentMounted/types';
-8
useIsComponentMounted.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useIsComponentMounted_1 = require("./hooks/useIsComponentMounted");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useIsComponentMounted_1).default; } });
-2
useIsFirstRender.d.ts
export { default } from './hooks/useIsFirstRender';
export { UseIsFirstRender } from './hooks/useIsFirstRender/types';
-8
useIsFirstRender.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useIsFirstRender_1 = require("./hooks/useIsFirstRender");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useIsFirstRender_1).default; } });
-2
usePrevious.d.ts
export { default } from './hooks/usePrevious';
export { UsePrevious } from './hooks/usePrevious/types';
-8
usePrevious.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var usePrevious_1 = require("./hooks/usePrevious");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(usePrevious_1).default; } });
-2
useResponsive.d.ts
export { default } from './hooks/useResponsive';
export { BaseConfig, Breakpoint, MediaQuery, EmptyBreakpoint } from './hooks/useResponsive/types';
-8
useResponsive.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useResponsive_1 = require("./hooks/useResponsive");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useResponsive_1).default; } });
-2
useScript.d.ts
export { default } from './hooks/useScript';
export { UseScript } from './hooks/useScript/types';
-8
useScript.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useScript_1 = require("./hooks/useScript");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useScript_1).default; } });
-2
useStableMemo.d.ts
export { default } from './hooks/useStableMemo';
export * from './hooks/useStableMemo/types';
-23
useStableMemo.js
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useStableMemo_1 = require("./hooks/useStableMemo");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useStableMemo_1).default; } });
__exportStar(require("./hooks/useStableMemo/types"), exports);
-2
useStateController.d.ts
export { default } from './hooks/useStateController';
export type { UseStateControllerParams, UseStateControllerResponse, OnStateChangeHandler, StateSelfUpdater } from './hooks/useStateController/types';
-8
useStateController.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useStateController_1 = require("./hooks/useStateController");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useStateController_1).default; } });
-2
useUnmountEffect.d.ts
export { default } from './hooks/useUnmountEffect';
export type { UseUnmountEffect } from './hooks/useUnmountEffect/types';
-8
useUnmountEffect.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = void 0;
var useUnmountEffect_1 = require("./hooks/useUnmountEffect");
Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useUnmountEffect_1).default; } });