Skip to content

GitLab

Commit 409c94b4 authored by baesangjune's avatar baesangjune
Browse files

rm node_modules

parent df52aea8
Hide whitespace changes
Inline Side-by-side
node_modules/@restart/hooks/cjs/useImage.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = useImage;
var _react = require("react");
/**
* Fetch and load an image for programatic use such as in a `<canvas>` element.
*
* @param imageOrUrl The `HtmlImageElement` or image url to load
* @param crossOrigin The `crossorigin` attribute to set
*
* ```ts
* const { image, error } = useImage('/static/kittens.png')
* const ref = useRef<HTMLCanvasElement>()
*
* useEffect(() => {
* const ctx = ref.current.getContext('2d')
*
* if (image) {
* ctx.drawImage(image, 0, 0)
* }
* }, [ref, image])
*
* return (
* <>
* {error && "there was a problem loading the image"}
* <canvas ref={ref} />
* </>
* ```
*/
function useImage(imageOrUrl, crossOrigin) {
var _useState = (0, _react.useState)({
image: null,
error: null
}),
state = _useState[0],
setState = _useState[1];
(0, _react.useEffect)(function () {
if (!imageOrUrl) return undefined;
var image;
if (typeof imageOrUrl === 'string') {
image = new Image();
if (crossOrigin) image.crossOrigin = crossOrigin;
image.src = imageOrUrl;
} else {
image = imageOrUrl;
if (image.complete && image.naturalHeight > 0) {
setState({
image: image,
error: null
});
return;
}
}
function onLoad() {
setState({
image: image,
error: null
});
}
function onError(error) {
setState({
image: image,
error: error
});
}
image.addEventListener('load', onLoad);
image.addEventListener('error', onError);
return function () {
image.removeEventListener('load', onLoad);
image.removeEventListener('error', onError);
};
}, [imageOrUrl, crossOrigin]);
return state;
}
\ No newline at end of file
node_modules/@restart/hooks/cjs/useImmediateUpdateEffect.d.ts deleted 100644 → 0
View file @ df52aea8
import { DependencyList, EffectCallback } from 'react';
/**
* An _immediate_ effect that runs an effect callback when its dependency array
* changes. This is helpful for updates should must run during render, most
* commonly state derived from props; a more ergonomic version of https://reactjs.org/docs/hooks-faq.html#how-do-i-implement-getderivedstatefromprops
*
* ```ts
* function Example({ value }) {
* const [intermediaryValue, setValue] = useState(value);
*
* useImmediateUpdateEffect(() => {
* setValue(value)
* }, [value])
* ```
*
* @category effects
*/
declare function useImmediateUpdateEffect(effect: EffectCallback, deps: DependencyList): void;
export default useImmediateUpdateEffect;
node_modules/@restart/hooks/cjs/useImmediateUpdateEffect.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = void 0;
var _react = require("react");
var _useStableMemo = _interopRequireDefault(require("./useStableMemo"));
var _useWillUnmount = _interopRequireDefault(require("./useWillUnmount"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* An _immediate_ effect that runs an effect callback when its dependency array
* changes. This is helpful for updates should must run during render, most
* commonly state derived from props; a more ergonomic version of https://reactjs.org/docs/hooks-faq.html#how-do-i-implement-getderivedstatefromprops
*
* ```ts
* function Example({ value }) {
* const [intermediaryValue, setValue] = useState(value);
*
* useImmediateUpdateEffect(() => {
* setValue(value)
* }, [value])
* ```
*
* @category effects
*/
function useImmediateUpdateEffect(effect, deps) {
var firstRef = (0, _react.useRef)(true);
var tearDown = (0, _react.useRef)();
(0, _useWillUnmount.default)(function () {
if (tearDown.current) tearDown.current();
});
(0, _useStableMemo.default)(function () {
if (firstRef.current) {
firstRef.current = false;
return;
}
if (tearDown.current) tearDown.current();
tearDown.current = effect();
}, deps);
}
var _default = useImmediateUpdateEffect;
exports.default = _default;
\ No newline at end of file
node_modules/@restart/hooks/cjs/useIntersectionObserver.d.ts deleted 100644 → 0
View file @ df52aea8
/**
* Setup an [`IntersectionObserver`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver) on
* a DOM Element.
*
* @param element The DOM element to observe
* @param init IntersectionObserver options
*/
export default function useIntersectionObserver<TElement extends Element>(element: TElement | null | undefined, { threshold, root, rootMargin }?: IntersectionObserverInit): IntersectionObserverEntry[];
node_modules/@restart/hooks/cjs/useIntersectionObserver.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = useIntersectionObserver;
var _react = require("react");
var _useStableMemo = _interopRequireDefault(require("./useStableMemo"));
var _useIsomorphicEffect = _interopRequireDefault(require("./useIsomorphicEffect"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Setup an [`IntersectionObserver`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver) on
* a DOM Element.
*
* @param element The DOM element to observe
* @param init IntersectionObserver options
*/
function useIntersectionObserver(element, _temp) {
var _ref = _temp === void 0 ? {} : _temp,
threshold = _ref.threshold,
root = _ref.root,
rootMargin = _ref.rootMargin;
var _useState = (0, _react.useState)(null),
entries = _useState[0],
setEntry = _useState[1];
var observer = (0, _useStableMemo.default)(function () {
return typeof IntersectionObserver !== 'undefined' && new IntersectionObserver(function (entries) {
return setEntry(entries);
}, {
threshold: threshold,
root: root,
rootMargin: rootMargin
});
}, [root, rootMargin, threshold && JSON.stringify(threshold)]);
(0, _useIsomorphicEffect.default)(function () {
if (!element || !observer) return;
observer.observe(element);
return function () {
observer.unobserve(element);
};
}, [observer, element]);
return entries || [];
}
\ No newline at end of file
node_modules/@restart/hooks/cjs/useInterval.d.ts deleted 100644 → 0
View file @ df52aea8
/**
* Creates a `setInterval` that is properly cleaned up when a component unmounted
*
* ```tsx
* function Timer() {
* const [timer, setTimer] = useState(0)
* useInterval(() => setTimer(i => i + 1), 1000)
*
* return <span>{timer} seconds past</span>
* }
* ```
*
* @param fn an function run on each interval
* @param ms The milliseconds duration of the interval
*/
declare function useInterval(fn: () => void, ms: number): void;
/**
* Creates a pausable `setInterval` that is properly cleaned up when a component unmounted
*
* ```tsx
* const [paused, setPaused] = useState(false)
* const [timer, setTimer] = useState(0)
*
* useInterval(() => setTimer(i => i + 1), 1000, paused)
*
* return (
* <span>
* {timer} seconds past
*
* <button onClick={() => setPaused(p => !p)}>{paused ? 'Play' : 'Pause' }</button>
* </span>
* )
* ```
*
* @param fn an function run on each interval
* @param ms The milliseconds duration of the interval
* @param paused Whether or not the interval is currently running
*/
declare function useInterval(fn: () => void, ms: number, paused: boolean): void;
/**
* Creates a pausable `setInterval` that _fires_ immediately and is
* properly cleaned up when a component unmounted
*
* ```tsx
* const [timer, setTimer] = useState(-1)
* useInterval(() => setTimer(i => i + 1), 1000, false, true)
*
* // will update to 0 on the first effect
* return <span>{timer} seconds past</span>
* ```
*
* @param fn an function run on each interval
* @param ms The milliseconds duration of the interval
* @param paused Whether or not the interval is currently running
* @param runImmediately Whether to run the function immediately on mount or unpause
* rather than waiting for the first interval to elapse
*
*/
declare function useInterval(fn: () => void, ms: number, paused: boolean, runImmediately: boolean): void;
export default useInterval;
node_modules/@restart/hooks/cjs/useInterval.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = void 0;
var _react = require("react");
var _useCommittedRef = _interopRequireDefault(require("./useCommittedRef"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function useInterval(fn, ms, paused, runImmediately) {
if (paused === void 0) {
paused = false;
}
if (runImmediately === void 0) {
runImmediately = false;
}
var handle;
var fnRef = (0, _useCommittedRef.default)(fn); // this ref is necessary b/c useEffect will sometimes miss a paused toggle
// orphaning a setTimeout chain in the aether, so relying on it's refresh logic is not reliable.
var pausedRef = (0, _useCommittedRef.default)(paused);
var tick = function tick() {
if (pausedRef.current) return;
fnRef.current();
schedule(); // eslint-disable-line no-use-before-define
};
var schedule = function schedule() {
clearTimeout(handle);
handle = setTimeout(tick, ms);
};
(0, _react.useEffect)(function () {
if (runImmediately) {
tick();
} else {
schedule();
}
return function () {
return clearTimeout(handle);
};
}, [paused, runImmediately]);
}
var _default = useInterval;
exports.default = _default;
\ No newline at end of file
node_modules/@restart/hooks/cjs/useIsomorphicEffect.d.ts deleted 100644 → 0
View file @ df52aea8
import { useEffect } from 'react';
declare const _default: typeof useEffect;
/**
* Is `useLayoutEffect` in a DOM or React Native environment, otherwise resolves to useEffect
* Only useful to avoid the console warning.
*
* PREFER `useEffect` UNLESS YOU KNOW WHAT YOU ARE DOING.
*
* @category effects
*/
export default _default;
node_modules/@restart/hooks/cjs/useIsomorphicEffect.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = void 0;
var _react = require("react");
var isReactNative = typeof global !== 'undefined' && // @ts-ignore
global.navigator && // @ts-ignore
global.navigator.product === 'ReactNative';
var isDOM = typeof document !== 'undefined';
/**
* Is `useLayoutEffect` in a DOM or React Native environment, otherwise resolves to useEffect
* Only useful to avoid the console warning.
*
* PREFER `useEffect` UNLESS YOU KNOW WHAT YOU ARE DOING.
*
* @category effects
*/
var _default = isDOM || isReactNative ? _react.useLayoutEffect : _react.useEffect;
exports.default = _default;
\ No newline at end of file
node_modules/@restart/hooks/cjs/useMap.d.ts deleted 100644 → 0
View file @ df52aea8
export declare class ObservableMap<K, V> extends Map<K, V> {
private readonly listener;
constructor(listener: (map: ObservableMap<K, V>) => void, init?: Iterable<Readonly<[K, V]>>);
set(key: K, value: V): this;
delete(key: K): boolean;
clear(): void;
}
/**
* Create and return a [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) that triggers rerenders when it's updated.
*
* ```tsx
* const customerAges = useMap<number>([
* ['john', 24],
* ['betsy', 25]
* ]);
*
* return (
* <>
* {Array.from(ids, ([name, age]) => (
* <div>
* {name}: {age}. <button onClick={() => ids.delete(name)}>X</button>
* </div>
* )}
* </>
* )
* ```
*
* @param init initial Map entries
*/
declare function useMap<K, V>(init?: Iterable<Readonly<[K, V]>>): ObservableMap<K, V>;
export default useMap;
node_modules/@restart/hooks/cjs/useMap.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = exports.ObservableMap = void 0;
var _useForceUpdate = _interopRequireDefault(require("./useForceUpdate"));
var _useStableMemo = _interopRequireDefault(require("./useStableMemo"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
var ObservableMap =
/*#__PURE__*/
function (_Map) {
_inheritsLoose(ObservableMap, _Map);
function ObservableMap(listener, init) {
var _this;
_this = _Map.call(this, init) || this;
_this.listener = listener;
return _this;
}
var _proto = ObservableMap.prototype;
_proto.set = function set(key, value) {
_Map.prototype.set.call(this, key, value); // When initializing the Map, the base Map calls this.set() before the
// listener is assigned so it will be undefined
if (this.listener) this.listener(this);
return this;
};
_proto.delete = function _delete(key) {
var result = _Map.prototype.delete.call(this, key);
this.listener(this);
return result;
};
_proto.clear = function clear() {
_Map.prototype.clear.call(this);
this.listener(this);
};
return ObservableMap;
}(
/*#__PURE__*/
_wrapNativeSuper(Map));
/**
* Create and return a [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) that triggers rerenders when it's updated.
*
* ```tsx
* const customerAges = useMap<number>([
* ['john', 24],
* ['betsy', 25]
* ]);
*
* return (
* <>
* {Array.from(ids, ([name, age]) => (
* <div>
* {name}: {age}. <button onClick={() => ids.delete(name)}>X</button>
* </div>
* )}
* </>
* )
* ```
*
* @param init initial Map entries
*/
exports.ObservableMap = ObservableMap;
function useMap(init) {
var forceUpdate = (0, _useForceUpdate.default)();
return (0, _useStableMemo.default)(function () {
return new ObservableMap(forceUpdate, init);
}, []);
}
var _default = useMap;
exports.default = _default;
\ No newline at end of file
node_modules/@restart/hooks/cjs/useMediaQuery.d.ts deleted 100644 → 0
View file @ df52aea8
/**
* Match a media query and get updates as the match changes. The media string is
* passed directly to `window.matchMedia` and run as a Layout Effect, so initial
* matches are returned before the browser has a chance to paint.
*
* ```tsx
* function Page() {
* const isWide = useMediaQuery('min-width: 1000px')
*
* return isWide ? "very wide" : 'not so wide'
* }
* ```
*
* Media query lists are also reused globally, hook calls for the same query
* will only create a matcher once under the hood.
*
* @param query A media query
*/
export default function useMediaQuery(query: string | null): boolean;
node_modules/@restart/hooks/cjs/useMediaQuery.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = useMediaQuery;
var _useIsomorphicEffect = _interopRequireDefault(require("./useIsomorphicEffect"));
var _react = require("react");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var isBool = function isBool(a) {
return typeof a === 'boolean';
};
var matchers = new Map();
var getMatcher = function getMatcher(query) {
if (!query || typeof window == 'undefined') return undefined;
var mql = matchers.get(query);
if (!mql) {
mql = window.matchMedia(query);
mql.refCount = 0;
matchers.set(mql.media, mql);
}
return mql;
};
/**
* Match a media query and get updates as the match changes. The media string is
* passed directly to `window.matchMedia` and run as a Layout Effect, so initial
* matches are returned before the browser has a chance to paint.
*
* ```tsx
* function Page() {
* const isWide = useMediaQuery('min-width: 1000px')
*
* return isWide ? "very wide" : 'not so wide'
* }
* ```
*
* Media query lists are also reused globally, hook calls for the same query
* will only create a matcher once under the hood.
*
* @param query A media query
*/
function useMediaQuery(query) {
var mql = getMatcher(query);
var _useState = (0, _react.useState)(function () {
return mql ? mql.matches : false;
}),
matches = _useState[0],
setMatches = _useState[1];
(0, _useIsomorphicEffect.default)(function () {
var mql = getMatcher(query);
if (!mql) {
return setMatches(false);
}
var handleChange = function handleChange() {
setMatches(mql.matches);
};
mql.refCount++;
mql.addListener(handleChange);
handleChange();
return function () {
mql.removeListener(handleChange);
mql.refCount--;
if (mql.refCount <= 0) {
matchers.delete(mql.media);
}
mql = undefined;
};
}, [query]);
return matches;
}
\ No newline at end of file
node_modules/@restart/hooks/cjs/useMergeState.d.ts deleted 100644 → 0
View file @ df52aea8
declare type Updater<TState> = (state: TState) => Partial<TState> | null;
/**
* Updates state, partial updates are merged into existing state values
*/
export declare type MergeStateSetter<TState> = (update: Updater<TState> | Partial<TState> | null) => void;
/**
* Mimics a React class component's state model, of having a single unified
* `state` object and an updater that merges updates into the existing state, as
* opposed to replacing it.
*
* ```js
* const [state, setState] = useMergeState({ name: 'Betsy', age: 24 })
*
* setState({ name: 'Johan' }) // { name: 'Johan', age: 24 }
*
* setState(state => ({ age: state.age + 10 })) // { name: 'Johan', age: 34 }
* ```
*
* @param initialState The initial state object
*/
export default function useMergeState<TState extends {}>(initialState: TState | (() => TState)): [TState, MergeStateSetter<TState>];
export {};
node_modules/@restart/hooks/cjs/useMergeState.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = useMergeState;
var _react = require("react");
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
/**
* Mimics a React class component's state model, of having a single unified
* `state` object and an updater that merges updates into the existing state, as
* opposed to replacing it.
*
* ```js
* const [state, setState] = useMergeState({ name: 'Betsy', age: 24 })
*
* setState({ name: 'Johan' }) // { name: 'Johan', age: 24 }
*
* setState(state => ({ age: state.age + 10 })) // { name: 'Johan', age: 34 }
* ```
*
* @param initialState The initial state object
*/
function useMergeState(initialState) {
var _useState = (0, _react.useState)(initialState),
state = _useState[0],
setState = _useState[1];
var updater = (0, _react.useCallback)(function (update) {
if (update === null) return;
if (typeof update === 'function') {
setState(function (state) {
var nextState = update(state);
return nextState == null ? state : _extends({}, state, {}, nextState);
});
} else {
setState(function (state) {
return _extends({}, state, {}, update);
});
}
}, [setState]);
return [state, updater];
}
\ No newline at end of file
node_modules/@restart/hooks/cjs/useMergeStateFromProps.d.ts deleted 100644 → 0
View file @ df52aea8
import { MergeStateSetter } from './useMergeState';
declare type Mapper<TProps, TState> = (props: TProps, state: TState) => null | Partial<TState>;
export default function useMergeStateFromProps<TProps, TState>(props: TProps, gDSFP: Mapper<TProps, TState>, initialState: TState): [TState, MergeStateSetter<TState>];
export {};
node_modules/@restart/hooks/cjs/useMergeStateFromProps.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.default = useMergeStateFromProps;
var _useMergeState2 = _interopRequireDefault(require("./useMergeState"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function useMergeStateFromProps(props, gDSFP, initialState) {
var _useMergeState = (0, _useMergeState2.default)(initialState),
state = _useMergeState[0],
setState = _useMergeState[1];
var nextState = gDSFP(props, state);
if (nextState !== null) setState(nextState);
return [state, setState];
}
\ No newline at end of file
node_modules/@restart/hooks/cjs/useMergedRefs.d.ts deleted 100644 → 0
View file @ df52aea8
/// <reference types="react" />
declare type CallbackRef<T> = (ref: T | null) => void;
declare type Ref<T> = React.MutableRefObject<T> | CallbackRef<T>;
export declare function mergeRefs<T>(refA?: Ref<T> | null, refB?: Ref<T> | null): (value: T | null) => void;
/**
* Create and returns a single callback ref composed from two other Refs.
*
* ```tsx
* const Button = React.forwardRef((props, ref) => {
* const [element, attachRef] = useCallbackRef<HTMLButtonElement>();
* const mergedRef = useMergedRefs(ref, attachRef);
*
* return <button ref={mergedRef} {...props}/>
* })
* ```
*
* @param refA A Callback or mutable Ref
* @param refB A Callback or mutable Ref
* @category refs
*/
declare function useMergedRefs<T>(refA?: Ref<T> | null, refB?: Ref<T> | null): (value: T | null) => void;
export default useMergedRefs;
node_modules/@restart/hooks/cjs/useMergedRefs.js deleted 100644 → 0
View file @ df52aea8
"use strict";
exports.__esModule = true;
exports.mergeRefs = mergeRefs;
exports.default = void 0;
var _react = require("react");
var toFnRef = function toFnRef(ref) {
return !ref || typeof ref === 'function' ? ref : function (value) {
ref.current = value;
};
};
function mergeRefs(refA, refB) {
var a = toFnRef(refA);
var b = toFnRef(refB);
return function (value) {
if (a) a(value);
if (b) b(value);
};
}
/**
* Create and returns a single callback ref composed from two other Refs.
*
* ```tsx
* const Button = React.forwardRef((props, ref) => {
* const [element, attachRef] = useCallbackRef<HTMLButtonElement>();
* const mergedRef = useMergedRefs(ref, attachRef);
*
* return <button ref={mergedRef} {...props}/>
* })
* ```
*
* @param refA A Callback or mutable Ref
* @param refB A Callback or mutable Ref
* @category refs
*/
function useMergedRefs(refA, refB) {
return (0, _react.useMemo)(function () {
return mergeRefs(refA, refB);
}, [refA, refB]);
}
var _default = useMergedRefs;
exports.default = _default;
\ No newline at end of file
node_modules/@restart/hooks/cjs/useMountEffect.d.ts deleted 100644 → 0
View file @ df52aea8
import { EffectCallback } from 'react';
/**
* Run's an effect on mount, and is cleaned up on unmount. Generally
* useful for interop with non-react plugins or components
*
* ```ts
* useMountEffect(() => {
* const plugin = $.myPlugin(ref.current)
*
* return () => {
* plugin.destroy()
* }
* })
* ```
* @param effect An effect to run on mount
*
* @category effects
*/
declare function useMountEffect(effect: EffectCallback): void;
export default useMountEffect;
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment