@aiszlab/relax 1.2.56 → 1.2.57

package/dist/hooks/use-scrollable.d.ts

@@ -1,17 +0,0 @@
-import { type Key } from 'react';
-import { type Direction } from '../dom/scroll-to';
-interface Dependencies {
-    direction?: Direction;
-}
-/**
- * @description
- * scrollable hook
- */
-export declare const useScrollable: <P extends HTMLElement, C extends HTMLElement>({ direction }?: Dependencies) => {
-    targetRef: import("react").RefObject<P>;
-    triggerRefs: import("react").MutableRefObject<Map<Key, C | null>>;
-    scrollTo: (to: number, duration?: number) => void;
-    to: (key: Key) => number;
-    setTrigger: (key: Key, trigger: C) => void;
-};
-export {};

package/dist/hooks/use-scrollable.js

@@ -1,43 +0,0 @@
-import { useRef, useCallback } from 'react';
-import { scrollTo } from '../dom/scroll-to.js';
-
-/**
- * @description
- * scrollable hook
- */
-var useScrollable = function useScrollable() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-    _ref$direction = _ref.direction,
-    direction = _ref$direction === void 0 ? 'vertical' : _ref$direction;
-  var targetRef = useRef(null);
-  var triggerRefs = useRef(new Map());
-  var scrollTo$1 = useCallback(function (to) {
-    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var target = targetRef.current;
-    if (!target) return;
-    // use animated scroll
-    scrollTo(target, to, {
-      duration: duration,
-      direction: direction
-    });
-  }, [direction]);
-  var to = useCallback(function (key) {
-    var trigger = triggerRefs.current.get(key);
-    if (!trigger) return 0;
-    // different direction, use different property
-    return direction === 'vertical' ? trigger.offsetTop : trigger.offsetLeft;
-  }, [direction]);
-  /// set trigger
-  var setTrigger = useCallback(function (key, trigger) {
-    triggerRefs.current.set(key, trigger);
-  }, []);
-  return {
-    targetRef: targetRef,
-    triggerRefs: triggerRefs,
-    scrollTo: scrollTo$1,
-    to: to,
-    setTrigger: setTrigger
-  };
-};
-
-export { useScrollable };

package/dist/hooks/use-throttle-callback.d.ts

@@ -1,18 +0,0 @@
-import { type Throttler, type Throttled } from '../utils/throttle';
-import { type Callable } from './use-event';
-/**
- * @author murukal
- *
- * @description
- * throttle callback
- *
- * @param callback
- * @param wait number
- * @description
- * The wait time (in milliseconds) until the throttle function is called.
- * default 1000
- *
- * @example
- * 1000
- */
-export declare const useThrottleCallback: <T extends Callable, R extends Array<unknown> = Parameters<T>>(throttler: T | Throttler<T, R>, wait?: number) => Throttled<T>;

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

@@ -1,83 +0,0 @@
-import { useRef, useEffect, useMemo } from 'react';
-import { throttle } from '../utils/throttle.js';
-import { useEvent } from './use-event.js';
-import { isFunction } from '../is/is-function.js';
-import { useDefault } from './use-default.js';
-
-var useThrottler = function useThrottler(throttler) {
-  var _useMemo = useMemo(function () {
-      return isFunction(throttler) ? {
-        callback: throttler,
-        pipe: null
-      } : throttler;
-    }, [throttler]),
-    callback = _useMemo.callback,
-    pipe = _useMemo.pipe;
-  return {
-    callback: useEvent(function () {
-      return callback.apply(void 0, arguments);
-    }),
-    pipe: useEvent(function () {
-      var _pipe;
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      return (_pipe = pipe === null || pipe === void 0 ? void 0 : pipe.apply(void 0, args)) !== null && _pipe !== void 0 ? _pipe : args;
-    })
-  };
-};
-/**
- * @author murukal
- *
- * @description
- * throttle callback
- *
- * @param callback
- * @param wait number
- * @description
- * The wait time (in milliseconds) until the throttle function is called.
- * default 1000
- *
- * @example
- * 1000
- */
-var useThrottleCallback = function useThrottleCallback(throttler) {
-  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
-  var throttled = useRef(null);
-  var _useThrottler = useThrottler(throttler),
-    callback = _useThrottler.callback,
-    pipe = _useThrottler.pipe;
-  useEffect(function () {
-    var _throttled = throttle({
-      callback: callback,
-      pipe: pipe
-    }, wait);
-    throttled.current = _throttled;
-    // dispose
-    return function () {
-      _throttled.abort();
-      throttled.current = null;
-    };
-  }, [wait]);
-  return useDefault(function () {
-    return {
-      next: function next() {
-        var _throttled$current;
-        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-          args[_key2] = arguments[_key2];
-        }
-        return (_throttled$current = throttled.current) === null || _throttled$current === void 0 ? void 0 : _throttled$current.next.apply(_throttled$current, args);
-      },
-      flush: function flush() {
-        var _throttled$current2;
-        return (_throttled$current2 = throttled.current) === null || _throttled$current2 === void 0 ? void 0 : _throttled$current2.flush();
-      },
-      abort: function abort() {
-        var _throttled$current3;
-        return (_throttled$current3 = throttled.current) === null || _throttled$current3 === void 0 ? void 0 : _throttled$current3.abort();
-      }
-    };
-  });
-};
-
-export { useThrottleCallback };

package/dist/hooks/use-timeout.d.ts

@@ -1,10 +0,0 @@
-/**
- * @author murukal
- *
- * @description
- * timeout effect
- */
-export declare const useTimeout: (callback: Function, wait: number) => {
-    flush: () => void;
-    cancel: () => void;
-};

package/dist/hooks/use-timeout.js

@@ -1,68 +0,0 @@
-import { useRef, useEffect } from 'react';
-import { Observable, timer } from 'rxjs';
-import { useEvent } from './use-event.js';
-import { useMounted } from './use-mounted.js';
-
-/**
- * @author murukal
- *
- * @description
- * timeout effect
- */
-var useTimeout = function useTimeout(callback, wait) {
-  var trigger = useRef(null);
-  var timed = useRef(null);
-  var callable = useEvent(callback);
-  useMounted(function () {
-    new Observable(function (_) {
-      trigger.current = _;
-    }).subscribe({
-      complete: function complete() {
-        return callable();
-      }
-    });
-  });
-  // when user what to flush timeout handler
-  // if trigger already registed, just complete trigger
-  // not registed, call `handler` manaully
-  var flush = useEvent(function () {
-    var _timed$current;
-    if (trigger.current) {
-      trigger.current.complete();
-    } else {
-      callback();
-    }
-    (_timed$current = timed.current) === null || _timed$current === void 0 || _timed$current.unsubscribe();
-    timed.current = null;
-    trigger.current = null;
-  });
-  // cancel
-  var cancel = useEvent(function () {
-    var _trigger$current, _timed$current2;
-    (_trigger$current = trigger.current) === null || _trigger$current === void 0 || _trigger$current.error();
-    (_timed$current2 = timed.current) === null || _timed$current2 === void 0 || _timed$current2.unsubscribe();
-    timed.current = null;
-  });
-  // add timer for `wait`
-  useEffect(function () {
-    // if 0, always mean not need to set timeout
-    if (wait <= 0) {
-      return;
-    }
-    var _timed = timer(wait).subscribe(function () {
-      var _trigger$current2;
-      (_trigger$current2 = trigger.current) === null || _trigger$current2 === void 0 || _trigger$current2.complete();
-    });
-    timed.current = _timed;
-    return function () {
-      _timed.unsubscribe();
-      timed.current = null;
-    };
-  }, [wait]);
-  return {
-    flush: flush,
-    cancel: cancel
-  };
-};
-
-export { useTimeout };

package/dist/hooks/use-togglable.d.ts

@@ -1,48 +0,0 @@
-import { type Key } from 'react';
-/**
- * @description
- * togglable key
- */
-type TogglableKey = {
-    /**
-     * @description
-     * unique key
-     */
-    key: Key;
-    /**
-     * @description
-     * children
-     */
-    children?: TogglableKey[];
-};
-/**
- * @description
- * extra options
- */
-type Options = {
-    /**
-     * @description
-     * default toggled
-     */
-    isDefaultToggled?: boolean;
-    /**
-     * @description
-     * toggled keys
-     */
-    toggledKeys?: Key[];
-    /**
-     * @description
-     * on toggle callback
-     */
-    onToggle?: (keys: Key[]) => void;
-};
-/**
- * @description
- * toggle able
- */
-export declare const useTogglable: (togglableKeys: TogglableKey[], { onToggle, ...options }?: Options) => {
-    toggledKeys: Set<Key>;
-    isToggled: (key: Key) => boolean;
-    toggle: (key: Key) => void;
-};
-export {};

package/dist/hooks/use-togglable.js

@@ -1,177 +0,0 @@
-import { objectWithoutProperties as _objectWithoutProperties, slicedToArray as _slicedToArray, createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, classCallCheck as _classCallCheck, classPrivateFieldInitSpec as _classPrivateFieldInitSpec, classPrivateFieldSet2 as _classPrivateFieldSet2 } from '../_virtual/_rollupPluginBabelHelpers.js';
-import { useMemo, useCallback } from 'react';
-import { useControlledState } from './use-controlled-state.js';
-import { useEvent } from './use-event.js';
-
-var _excluded = ["onToggle"];
-var _groupedLeaves = /*#__PURE__*/new WeakMap();
-var Tree = /*#__PURE__*/function () {
-  function Tree() {
-    _classCallCheck(this, Tree);
-    _classPrivateFieldInitSpec(this, _groupedLeaves, void 0);
-    _classPrivateFieldSet2(_groupedLeaves, this, new Map());
-  }
-  return _createClass(Tree, [{
-    key: "groupedLeaves",
-    get: function get() {
-      return _classPrivateFieldGet2(_groupedLeaves, this);
-    }
-  }, {
-    key: "grow",
-    value: function grow(togglableKey) {
-      // create leaf, leaf will auto trigger tree collect callback
-      new Leaf({
-        key: togglableKey.key,
-        parent: null,
-        belongTo: this
-      }).grow(togglableKey.children);
-      return this;
-    }
-  }, {
-    key: "collect",
-    value: function collect(leaf) {
-      _classPrivateFieldGet2(_groupedLeaves, this).has(leaf.key) ? _classPrivateFieldGet2(_groupedLeaves, this).get(leaf.key).add(leaf) : _classPrivateFieldGet2(_groupedLeaves, this).set(leaf.key, new Set([leaf]));
-    }
-  }, {
-    key: "toggle",
-    value: function toggle(key, toggledKeys) {
-      var hasToggled = toggledKeys.has(key);
-      var isToggled = !hasToggled;
-      return this.toggleBy(key, isToggled, toggledKeys);
-    }
-  }, {
-    key: "toggleBy",
-    value: function toggleBy(key, isToggled, toggledKeys) {
-      var _classPrivateFieldGet2$1;
-      return Array.from((_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_groupedLeaves, this).get(key)) !== null && _classPrivateFieldGet2$1 !== void 0 ? _classPrivateFieldGet2$1 : []).reduce(function (prev, leaf) {
-        // deep fall, add or remove child key
-        // deep rise, add or remove parent key
-        return leaf.rise(isToggled, leaf.fall(isToggled, prev));
-      }, new Set(toggledKeys));
-    }
-  }]);
-}();
-var _key = /*#__PURE__*/new WeakMap();
-var _belongTo = /*#__PURE__*/new WeakMap();
-var _parent = /*#__PURE__*/new WeakMap();
-var _children = /*#__PURE__*/new WeakMap();
-var Leaf = /*#__PURE__*/function () {
-  function Leaf(props) {
-    _classCallCheck(this, Leaf);
-    _classPrivateFieldInitSpec(this, _key, void 0);
-    _classPrivateFieldInitSpec(this, _belongTo, void 0);
-    _classPrivateFieldInitSpec(this, _parent, void 0);
-    _classPrivateFieldInitSpec(this, _children, void 0);
-    _classPrivateFieldSet2(_key, this, props.key);
-    _classPrivateFieldSet2(_parent, this, props.parent);
-    _classPrivateFieldSet2(_belongTo, this, props.belongTo);
-    _classPrivateFieldSet2(_children, this, []);
-    // when leaf has grew, let tree collect leaf
-    _classPrivateFieldGet2(_belongTo, this).collect(this);
-  }
-  return _createClass(Leaf, [{
-    key: "key",
-    get: function get() {
-      return _classPrivateFieldGet2(_key, this);
-    }
-  }, {
-    key: "grow",
-    value: function grow() {
-      var _this = this;
-      var children = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      if (children.length === 0) return this;
-      children.forEach(function (node) {
-        var child = new Leaf({
-          key: node.key,
-          parent: _this,
-          belongTo: _classPrivateFieldGet2(_belongTo, _this)
-        }).grow(node.children);
-        _classPrivateFieldGet2(_children, _this).push(child);
-      });
-      return this;
-    }
-  }, {
-    key: "rise",
-    value: function rise(isToggled, toggledKeys) {
-      var rised = new Set(toggledKeys);
-      if (isToggled) {
-        rised.add(_classPrivateFieldGet2(_key, this));
-      } else {
-        rised["delete"](_classPrivateFieldGet2(_key, this));
-      }
-      if (_classPrivateFieldGet2(_parent, this)) {
-        return _classPrivateFieldGet2(_parent, this).rise(isToggled, rised);
-      }
-      return rised;
-    }
-  }, {
-    key: "fall",
-    value: function fall(isToggled, toggledKeys) {
-      return _classPrivateFieldGet2(_children, this).reduce(function (prev, leaf) {
-        // deep loop, remove or add key
-        var fell = leaf.fall(isToggled, prev);
-        // toggle true, add current leaf key
-        // toggle false, remove current leaf key
-        if (isToggled) {
-          fell.add(leaf.key);
-        } else {
-          fell["delete"](leaf.key);
-        }
-        return fell;
-      }, new Set(toggledKeys));
-    }
-  }]);
-}();
-/**
- * @description
- * toggle able
- */
-var useTogglable = function useTogglable(togglableKeys) {
-  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    onToggle = _ref.onToggle,
-    options = _objectWithoutProperties(_ref, _excluded);
-  /// re-create tree when togglable keys changed
-  var tree = useMemo(function () {
-    return togglableKeys.reduce(function (_tree, togglable) {
-      return _tree.grow(togglable);
-    }, new Tree());
-  }, [togglableKeys]);
-  /// use controlled state to record toggled keys
-  var _useControlledState = useControlledState(options.toggledKeys, {
-      defaultState: function defaultState() {
-        return options.isDefaultToggled ? Array.from(Array.from(tree.groupedLeaves.values()).reduce(function (prev, leaves) {
-          leaves.forEach(function (leaf) {
-            return prev.add(leaf.key);
-          });
-          return prev;
-        }, new Set())) : [];
-      }
-    }),
-    _useControlledState2 = _slicedToArray(_useControlledState, 2),
-    _toggledKeys = _useControlledState2[0],
-    _setToggledKeys = _useControlledState2[1];
-  /// use set for toggled keys to make it read-only
-  var readableToggledKeys = useMemo(function () {
-    return new Set(_toggledKeys);
-  }, [_toggledKeys]);
-  /// check current key is toggled
-  var isToggled = useCallback(function (key) {
-    return !readableToggledKeys || readableToggledKeys.has(key);
-  }, [readableToggledKeys]);
-  /// toggle one key
-  var toggle = useEvent(function (key) {
-    // get new toggled keys by toggle current key
-    var _toggledKeys = Array.from(tree.toggle(key, readableToggledKeys));
-    // set state
-    _setToggledKeys(_toggledKeys);
-    // trigger on toggle callback
-    onToggle === null || onToggle === void 0 || onToggle(_toggledKeys);
-  });
-  return {
-    toggledKeys: readableToggledKeys,
-    isToggled: isToggled,
-    toggle: toggle
-  };
-};
-
-export { useTogglable };

package/dist/hooks/use-toggleable.d.ts

@@ -1,48 +0,0 @@
-import { type Key } from 'react';
-/**
- * @description
- * togglable key
- */
-type TogglableKey = {
-    /**
-     * @description
-     * unique key
-     */
-    key: Key;
-    /**
-     * @description
-     * children
-     */
-    children?: TogglableKey[];
-};
-/**
- * @description
- * extra options
- */
-type Options = {
-    /**
-     * @description
-     * default toggled
-     */
-    isDefaultToggled?: boolean;
-    /**
-     * @description
-     * toggled keys
-     */
-    toggledKeys?: Key[];
-    /**
-     * @description
-     * on toggle callback
-     */
-    onToggle?: (keys: Key[]) => void;
-};
-/**
- * @description
- * toggle able
- */
-export declare const useTogglable: (togglableKeys: TogglableKey[], { onToggle, ...options }?: Options) => {
-    toggledKeys: Set<Key>;
-    isToggled: (key: Key) => boolean;
-    toggle: (key: Key) => void;
-};
-export {};