@aiszlab/relax 1.2.37 → 1.2.39

package/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,153 @@
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
+}
+function _classPrivateFieldGet2(s, a) {
+  return s.get(_assertClassBrand(s, a));
+}
+function _classPrivateFieldSet2(s, a, r) {
+  return s.set(_assertClassBrand(s, a), r), r;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r );
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _classPrivateFieldInitSpec(obj, privateMap, value) {
+  _checkPrivateRedeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  _checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _assertClassBrand as assertClassBrand, _checkPrivateRedeclaration as checkPrivateRedeclaration, _classCallCheck as classCallCheck, _classPrivateFieldGet2 as classPrivateFieldGet2, _classPrivateFieldInitSpec as classPrivateFieldInitSpec, _classPrivateFieldSet2 as classPrivateFieldSet2, _classPrivateMethodInitSpec as classPrivateMethodInitSpec, _createClass as createClass, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectWithoutProperties as objectWithoutProperties, _objectWithoutPropertiesLoose as objectWithoutPropertiesLoose, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _typeof as typeof, _unsupportedIterableToArray as unsupportedIterableToArray };

package/dist/dom/contains.js

@@ -0,0 +1,20 @@
+var contains = function contains(root, n) {
+  if (!root) {
+    return false;
+  }
+  // Use native if support
+  if (root.contains) {
+    return root.contains(n !== null && n !== void 0 ? n : null);
+  }
+  // `document.contains` not support with IE11
+  var node = n;
+  while (node) {
+    if (node === root) {
+      return true;
+    }
+    node = node.parentNode;
+  }
+  return false;
+};
+
+export { contains };

package/dist/dom/index.js

@@ -0,0 +1,2 @@
+export { scrollTo } from './scroll-to.js';
+export { contains } from './contains.js';

package/dist/dom/scroll-to.js

@@ -0,0 +1,69 @@
+import { createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, classCallCheck as _classCallCheck, classPrivateFieldInitSpec as _classPrivateFieldInitSpec } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+var _scrolled = /*#__PURE__*/new WeakMap();
+var Scroller = /*#__PURE__*/function () {
+  function Scroller() {
+    var _scroller$_;
+    _classCallCheck(this, Scroller);
+    _classPrivateFieldInitSpec(this, _scrolled, new Map());
+    return (_scroller$_ = _scroller._) !== null && _scroller$_ !== void 0 ? _scroller$_ : _scroller._ = this;
+  }
+  return _createClass(Scroller, [{
+    key: "scrolled",
+    get: function get() {
+      return _classPrivateFieldGet2(_scrolled, this);
+    }
+  }, {
+    key: "currentAt",
+    value: function currentAt(direction) {
+      return direction === 'vertical' ? 'scrollTop' : 'scrollLeft';
+    }
+  }]);
+}();
+/**
+ * @description
+ * scroll to for wrapper element
+ */
+// singleton mode
+var _scroller = {
+  _: null
+};
+var scrollTo = function scrollTo(target, to) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      duration: 0,
+      direction: 'vertical'
+    },
+    _ref$duration = _ref.duration,
+    duration = _ref$duration === void 0 ? 0 : _ref$duration,
+    _ref$direction = _ref.direction,
+    direction = _ref$direction === void 0 ? 'vertical' : _ref$direction;
+  var scroller = new Scroller();
+  var scrolled = scroller.scrolled.get(target);
+  var currentAtProperty = scroller.currentAt(direction);
+  if (scrolled) {
+    cancelAnimationFrame(scrolled);
+    scroller.scrolled["delete"](target);
+  }
+  // if duration <= 0, jump immediately
+  if (duration <= 0) {
+    scroller.scrolled.set(target, requestAnimationFrame(function () {
+      target[currentAtProperty] = to;
+    }));
+    return;
+  }
+  // animate
+  var currentAt = target[currentAtProperty];
+  var difference = to - currentAt;
+  var step = difference / duration * 10;
+  scroller.scrolled.set(target, requestAnimationFrame(function () {
+    target[currentAtProperty] = currentAt + step;
+    // over end, stop any animation
+    if (target[currentAtProperty] === to) return;
+    scrollTo(target, to, {
+      duration: duration - 10,
+      direction: direction
+    });
+  }));
+};
+
+export { scrollTo };

package/dist/hooks/use-boolean.js

@@ -0,0 +1,34 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useCallback } from 'react';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * boolean state, in relax, we already create some api to easy use
+ */
+var useBoolean = function useBoolean(initialState) {
+  var _useState = useState(initialState !== null && initialState !== void 0 ? initialState : false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isOn = _useState2[0],
+    setIsOn = _useState2[1];
+  var turnOn = useCallback(function () {
+    return setIsOn(true);
+  }, []);
+  var turnOff = useCallback(function () {
+    return setIsOn(false);
+  }, []);
+  var toggle = useCallback(function () {
+    return setIsOn(function (_isOn) {
+      return !_isOn;
+    });
+  }, []);
+  return [isOn, {
+    turnOn: turnOn,
+    turnOff: turnOff,
+    toggle: toggle,
+    setBoolean: setIsOn
+  }];
+};
+
+export { useBoolean };

package/dist/hooks/use-controlled-state.js

@@ -0,0 +1,40 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState } from 'react';
+import { isStateGetter } from '../is/is-state-getter.js';
+import { isUndefined } from '../is/is-undefined.js';
+import { useUpdateEffect } from './use-update-effect.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * controlled state
+ */
+var useControlledState = function useControlledState(controlledState) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    defaultState = _ref.defaultState;
+  /// initialize state
+  var _useState = useState(function () {
+      // default use controlled state
+      if (!isUndefined(controlledState)) {
+        return controlledState;
+      }
+      // not controlled use default prop
+      if (isUndefined(defaultState)) return controlledState;
+      if (isStateGetter(defaultState)) return defaultState();
+      return defaultState;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    _state = _useState2[0],
+    _setState = _useState2[1];
+  /// sync value back to `undefined` when it from control to un-control
+  useUpdateEffect(function () {
+    if (!isUndefined(controlledState)) return;
+    _setState(controlledState !== null && controlledState !== void 0 ? controlledState : defaultState);
+  }, [controlledState]);
+  /// use controlled
+  var state = !isUndefined(controlledState) ? controlledState : _state;
+  return [state, _setState];
+};
+
+export { useControlledState };

package/dist/hooks/use-counter.js

@@ -0,0 +1,60 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useCallback, useMemo } from 'react';
+import { clamp } from '../utils/clamp/index.js';
+import { useDefault } from './use-default.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * a number counter with some useful apis
+ */
+var useCounter = function useCounter(initialState) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      max: Infinity,
+      min: -Infinity
+    },
+    _ref$max = _ref.max,
+    max = _ref$max === void 0 ? Infinity : _ref$max,
+    _ref$min = _ref.min,
+    min = _ref$min === void 0 ? -Infinity : _ref$min;
+  var defaultState = useDefault(initialState !== null && initialState !== void 0 ? initialState : 0);
+  var _useState = useState(defaultState),
+    _useState2 = _slicedToArray(_useState, 2),
+    _count = _useState2[0],
+    _setCount = _useState2[1];
+  var add = useCallback(function () {
+    var step = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    _setCount(function (prev) {
+      return Math.min(max, prev + step);
+    });
+  }, [max]);
+  var subtract = useCallback(function () {
+    var step = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    _setCount(function (prev) {
+      return Math.max(min, prev - step);
+    });
+  }, [min]);
+  var first = useCallback(function () {
+    _setCount(min);
+  }, [min]);
+  var last = useCallback(function () {
+    _setCount(max);
+  }, [max]);
+  var reset = useCallback(function () {
+    _setCount(defaultState);
+  }, []);
+  var count = useMemo(function () {
+    return clamp(_count, min, max);
+  }, [_count, min, max]);
+  return [count, {
+    add: add,
+    subtract: subtract,
+    first: first,
+    last: last,
+    reset: reset,
+    setCount: _setCount
+  }];
+};
+
+export { useCounter };

package/dist/hooks/use-debounce-callback.js

@@ -0,0 +1,81 @@
+import { useRef, useEffect, useMemo } from 'react';
+import { debounce } from '../utils/debounce/index.js';
+import { useEvent } from './use-event.js';
+import { isFunction } from '../is/is-function.js';
+import { useDefault } from './use-default.js';
+
+var useDebouncer = function useDebouncer(debouncer) {
+  var _debouncer = useMemo(function () {
+    return isFunction(debouncer) ? {
+      callback: debouncer,
+      pipe: null
+    } : debouncer;
+  }, [debouncer]);
+  return {
+    callback: useEvent(function () {
+      return _debouncer.callback.apply(_debouncer, arguments);
+    }),
+    pipe: useEvent(function () {
+      var _debouncer$pipe, _debouncer$pipe2;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return (_debouncer$pipe = (_debouncer$pipe2 = _debouncer.pipe) === null || _debouncer$pipe2 === void 0 ? void 0 : _debouncer$pipe2.call.apply(_debouncer$pipe2, [_debouncer].concat(args))) !== null && _debouncer$pipe !== void 0 ? _debouncer$pipe : args;
+    })
+  };
+};
+/**
+ * @author murukal
+ *
+ * @description
+ * debounce callback
+ *
+ * @param callback
+ * @param wait number
+ * @description
+ * The delay time (in milliseconds) until the debounce function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
+ */
+var useDebounceCallback = function useDebounceCallback(debouncer) {
+  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  var debounced = useRef(null);
+  var _useDebouncer = useDebouncer(debouncer),
+    callback = _useDebouncer.callback,
+    pipe = _useDebouncer.pipe;
+  useEffect(function () {
+    var _debounced = debounce({
+      callback: callback,
+      pipe: pipe
+    }, wait);
+    debounced.current = _debounced;
+    // dispose
+    return function () {
+      _debounced.abort();
+      debounced.current = null;
+    };
+  }, [wait]);
+  return useDefault(function () {
+    return {
+      next: function next() {
+        var _debounced$current;
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return (_debounced$current = debounced.current) === null || _debounced$current === void 0 ? void 0 : _debounced$current.next.apply(_debounced$current, args);
+      },
+      flush: function flush() {
+        var _debounced$current2;
+        return (_debounced$current2 = debounced.current) === null || _debounced$current2 === void 0 ? void 0 : _debounced$current2.flush();
+      },
+      abort: function abort() {
+        var _debounced$current3;
+        return (_debounced$current3 = debounced.current) === null || _debounced$current3 === void 0 ? void 0 : _debounced$current3.abort();
+      }
+    };
+  });
+};
+
+export { useDebounceCallback };

package/dist/hooks/use-default.js

@@ -0,0 +1,14 @@
+import { useMemo } from 'react';
+import { toFunction } from '../utils/to-function.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * state always be same after first render
+ */
+var useDefault = function useDefault(initialState) {
+  return useMemo(toFunction(initialState), []);
+};
+
+export { useDefault };

package/dist/hooks/use-event.js

@@ -0,0 +1,12 @@
+import { useRef, useCallback } from 'react';
+
+var useEvent = function useEvent(callback) {
+  var ref = useRef(callback);
+  ref.current = callback;
+  // @ts-ignore
+  return useCallback(function () {
+    return ref.current.apply(ref, arguments);
+  }, []);
+};
+
+export { useEvent };

package/dist/hooks/use-focus.js

@@ -0,0 +1,31 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useCallback } from 'react';
+import { useBoolean } from './use-boolean.js';
+import { chain } from '../utils/chain/index.js';
+
+var useFocus = function useFocus(props) {
+  var _useBoolean = useBoolean(false),
+    _useBoolean2 = _slicedToArray(_useBoolean, 2),
+    isFocused = _useBoolean2[0],
+    _useBoolean2$ = _useBoolean2[1],
+    turnOn = _useBoolean2$.turnOn,
+    turnOff = _useBoolean2$.turnOff;
+  var onFocus = useCallback(function (e) {
+    chain(props === null || props === void 0 ? void 0 : props.onFocus, turnOn, function () {
+      var _props$onFocusChange;
+      return props === null || props === void 0 || (_props$onFocusChange = props.onFocusChange) === null || _props$onFocusChange === void 0 ? void 0 : _props$onFocusChange.call(props, true);
+    })(e);
+  }, [props === null || props === void 0 ? void 0 : props.onFocus, props === null || props === void 0 ? void 0 : props.onFocusChange]);
+  var onBlur = useCallback(function (e) {
+    chain(props === null || props === void 0 ? void 0 : props.onBlur, turnOff, function () {
+      var _props$onFocusChange2;
+      return props === null || props === void 0 || (_props$onFocusChange2 = props.onFocusChange) === null || _props$onFocusChange2 === void 0 ? void 0 : _props$onFocusChange2.call(props, false);
+    })(e);
+  }, [props === null || props === void 0 ? void 0 : props.onBlur, props === null || props === void 0 ? void 0 : props.onFocusChange]);
+  return [isFocused, {
+    onFocus: onFocus,
+    onBlur: onBlur
+  }];
+};
+
+export { useFocus };

package/dist/hooks/use-force-update.js

@@ -0,0 +1,21 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useCallback } from 'react';
+
+/**
+ * @description
+ * force update
+ */
+var useForceUpdate = function useForceUpdate() {
+  var _useState = useState(1),
+    _useState2 = _slicedToArray(_useState, 2),
+    times = _useState2[0],
+    setTimes = _useState2[1];
+  var forceUpdate = useCallback(function () {
+    setTimes(function (prev) {
+      return prev + 1;
+    });
+  }, []);
+  return [times, forceUpdate];
+};
+
+export { useForceUpdate };

package/dist/hooks/use-hover.js

@@ -0,0 +1,25 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useCallback } from 'react';
+import { useBoolean } from './use-boolean.js';
+import { chain } from '../utils/chain/index.js';
+
+var useHover = function useHover(props) {
+  var _useBoolean = useBoolean(false),
+    _useBoolean2 = _slicedToArray(_useBoolean, 2),
+    isHovered = _useBoolean2[0],
+    _useBoolean2$ = _useBoolean2[1],
+    turnOn = _useBoolean2$.turnOn,
+    turnOff = _useBoolean2$.turnOff;
+  var onPointerEnter = useCallback(function (e) {
+    chain(props === null || props === void 0 ? void 0 : props.onEnter, turnOn)(e);
+  }, [props === null || props === void 0 ? void 0 : props.onEnter]);
+  var onPointerLeave = useCallback(function (e) {
+    chain(props === null || props === void 0 ? void 0 : props.onLeave, turnOff)(e);
+  }, [props === null || props === void 0 ? void 0 : props.onLeave]);
+  return [isHovered, {
+    onPointerEnter: onPointerEnter,
+    onPointerLeave: onPointerLeave
+  }];
+};
+
+export { useHover };

package/dist/hooks/use-image-loader.js

@@ -0,0 +1,54 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useRef, useState, useEffect } from 'react';
+import { Observable } from 'rxjs';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * image loader
+ */
+var useImageLoader = function useImageLoader(_ref) {
+  var src = _ref.src;
+  var loader = useRef();
+  var _useState = useState('none'),
+    _useState2 = _slicedToArray(_useState, 2),
+    status = _useState2[0],
+    setStatus = _useState2[1];
+  useEffect(function () {
+    if (!src) {
+      return setStatus('none');
+    }
+    // create observable to listen img status
+    new Observable(function (subscriber) {
+      loader.current = subscriber;
+      subscriber.next();
+    }).subscribe({
+      next: function next() {
+        return setStatus('loading');
+      },
+      complete: function complete() {
+        return setStatus('loaded');
+      },
+      error: function error() {
+        return setStatus('error');
+      }
+    });
+    var image = new Image();
+    image.addEventListener('load', function () {
+      var _loader$current;
+      (_loader$current = loader.current) === null || _loader$current === void 0 || _loader$current.complete();
+    });
+    image.addEventListener('error', function () {
+      var _loader$current2;
+      (_loader$current2 = loader.current) === null || _loader$current2 === void 0 || _loader$current2.error(null);
+    });
+    image.src = src;
+    return function () {
+      image.remove();
+    };
+  }, [src]);
+  return status;
+};
+
+export { useImageLoader };

package/dist/hooks/use-memorable.js

@@ -0,0 +1,14 @@
+import * as React from 'react';
+
+var useMemorable = function useMemorable(getter, condition, shouldUpdate) {
+  var cacheRef = React.useRef(null);
+  if (cacheRef.current === null || shouldUpdate(cacheRef.current.condition, condition)) {
+    cacheRef.current = {
+      value: getter(),
+      condition: condition
+    };
+  }
+  return cacheRef.current.value;
+};
+
+export { useMemorable };

package/dist/hooks/use-mount.js

@@ -0,0 +1,16 @@
+import { useLayoutEffect } from 'react';
+import { effect } from '../utils/effect/index.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * when components will mount
+ */
+var useMount = function useMount(callback) {
+  useLayoutEffect(function () {
+    return effect(callback);
+  }, []);
+};
+
+export { useMount };

package/dist/hooks/use-mounted.js

@@ -0,0 +1,16 @@
+import { useEffect } from 'react';
+import { effect } from '../utils/effect/index.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * when components mounted
+ */
+var useMounted = function useMounted(callback) {
+  useEffect(function () {
+    return effect(callback);
+  }, []);
+};
+
+export { useMounted };