@aiszlab/relax 1.2.11-beta.5 → 1.2.11-beta.6

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

@@ -30,13 +30,17 @@ type Options = {
      * toggled keys
      */
     toggledKeys?: Key[];
+    /**
+     * @description
+     * on toggle callback
+     */
+    onToggle?: (keys: Key[]) => void;
 };
 /**
  * @description
  * toggle able
  */
-export declare const useToggleable: (toggleableKeys: ToggleableKey[], options?: Options) => {
-    isAllToggled: boolean;
+export declare const useToggleable: (toggleableKeys: ToggleableKey[], { onToggle, ...options }?: Options) => {
     toggledKeys: Set<Key>;
     isToggled: (key: Key) => boolean;
     toggle: (key: Key) => void;

package/dist/hooks/use-toggleable.js

@@ -1,97 +1,63 @@
-import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.js';
-import { useRef, useMemo, useEffect, useCallback } from 'react';
+import { __rest, __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.js';
+import { useMemo, useCallback } from 'react';
+import { useControlledState } from './use-controlled-state.js';
 
-var _Tree_leaves, _Tree_toggledLeaves, _Tree_groupedLeaves, _Tree_isDefaultToggled, _Leaf_key, _Leaf_belongTo, _Leaf_parent, _Leaf_children, _Leaf_toggledChildren;
+var _Tree_groupedLeaves, _Leaf_key, _Leaf_belongTo, _Leaf_parent, _Leaf_children;
 class Tree {
-    constructor({ isDefaultToggled }) {
-        _Tree_leaves.set(this, void 0);
-        _Tree_toggledLeaves.set(this, void 0);
+    constructor() {
         _Tree_groupedLeaves.set(this, void 0);
-        _Tree_isDefaultToggled.set(this, void 0);
-        __classPrivateFieldSet(this, _Tree_leaves, new Set(), "f");
-        __classPrivateFieldSet(this, _Tree_toggledLeaves, new Set(), "f");
         __classPrivateFieldSet(this, _Tree_groupedLeaves, new Map(), "f");
-        __classPrivateFieldSet(this, _Tree_isDefaultToggled, !!isDefaultToggled, "f");
-    }
-    get isAllToggled() {
-        return __classPrivateFieldGet(this, _Tree_leaves, "f").size === __classPrivateFieldGet(this, _Tree_toggledLeaves, "f").size;
-    }
-    get toggledLeaves() {
-        return __classPrivateFieldGet(this, _Tree_toggledLeaves, "f");
     }
     get groupedLeaves() {
         return __classPrivateFieldGet(this, _Tree_groupedLeaves, "f");
     }
     grow(toggleableKey) {
-        __classPrivateFieldGet(this, _Tree_leaves, "f").add(new Leaf({
+        // create leaf, leaf will auto trigger tree collect callback
+        new Leaf({
             key: toggleableKey.key,
             parent: null,
             belongTo: this
-        }).grow(toggleableKey.children));
+        }).grow(toggleableKey.children);
         return this;
     }
     collect(leaf) {
         __classPrivateFieldGet(this, _Tree_groupedLeaves, "f").has(leaf.key)
             ? __classPrivateFieldGet(this, _Tree_groupedLeaves, "f").set(leaf.key, new Set([leaf]))
             : __classPrivateFieldGet(this, _Tree_groupedLeaves, "f").get(leaf.key).add(leaf);
-        // if default toggled, add leaf to toggled leaves
-        __classPrivateFieldGet(this, _Tree_isDefaultToggled, "f") && this.toggledLeaves.add(leaf);
     }
-    toggle(key) {
-        const leaves = __classPrivateFieldGet(this, _Tree_groupedLeaves, "f").get(key);
-        if (!(leaves === null || leaves === void 0 ? void 0 : leaves.size))
-            return;
-        leaves.forEach((leaf) => {
-            const _isToggled = this.toggledLeaves.has(leaf);
-            leaf.toggleBy(!_isToggled);
-        });
+    toggle(key, toggledKeys) {
+        const hasToggled = toggledKeys.has(key);
+        const _isToggled = !hasToggled;
+        return this.toggleBy(key, _isToggled, toggledKeys);
     }
-    toggleWith(keys) {
-        this.toggledLeaves.clear();
-        keys.forEach((key) => {
-            var _a;
-            (_a = __classPrivateFieldGet(this, _Tree_groupedLeaves, "f").get(key)) === null || _a === void 0 ? void 0 : _a.forEach((leaf) => {
-                __classPrivateFieldGet(this, _Tree_toggledLeaves, "f").add(leaf);
-            });
-        });
+    toggleBy(key, isToggled, toggledKeys) {
+        var _a;
+        return Array.from((_a = __classPrivateFieldGet(this, _Tree_groupedLeaves, "f").get(key)) !== null && _a !== void 0 ? _a : []).reduce((prev, leaf) => {
+            // deep fall, add or remove child key
+            const fell = leaf.fall(isToggled, prev);
+            // deep rise, add or remove parent key
+            const rised = leaf.rise(fell);
+            return rised;
+        }, new Set(toggledKeys));
     }
 }
-_Tree_leaves = new WeakMap(), _Tree_toggledLeaves = new WeakMap(), _Tree_groupedLeaves = new WeakMap(), _Tree_isDefaultToggled = new WeakMap();
+_Tree_groupedLeaves = new WeakMap();
 class Leaf {
     constructor(props) {
         _Leaf_key.set(this, void 0);
         _Leaf_belongTo.set(this, void 0);
         _Leaf_parent.set(this, void 0);
         _Leaf_children.set(this, void 0);
-        _Leaf_toggledChildren.set(this, void 0);
         __classPrivateFieldSet(this, _Leaf_key, props.key, "f");
         __classPrivateFieldSet(this, _Leaf_parent, props.parent, "f");
         __classPrivateFieldSet(this, _Leaf_belongTo, props.belongTo, "f");
-        __classPrivateFieldSet(this, _Leaf_children, new Set(), "f");
-        __classPrivateFieldSet(this, _Leaf_toggledChildren, new Set(), "f");
+        __classPrivateFieldSet(this, _Leaf_children, [], "f");
         // when leaf has grew, let tree collect leaf
         __classPrivateFieldGet(this, _Leaf_belongTo, "f").collect(this);
     }
     get key() {
         return __classPrivateFieldGet(this, _Leaf_key, "f");
     }
-    toggleBy(isToggled, isPrevent = false) {
-        var _a;
-        if (isToggled) {
-            __classPrivateFieldGet(this, _Leaf_belongTo, "f").toggledLeaves.add(this);
-        }
-        else {
-            __classPrivateFieldGet(this, _Leaf_belongTo, "f").toggledLeaves.delete(this);
-        }
-        if (isPrevent)
-            return;
-        // fall to every child
-        Array.from(__classPrivateFieldGet(this, _Leaf_children, "f").values()).forEach((child) => {
-            child.fall(isToggled);
-        });
-        // rise to parent
-        (_a = __classPrivateFieldGet(this, _Leaf_parent, "f")) === null || _a === void 0 ? void 0 : _a.rise(this, isToggled);
-    }
     grow(toggleableKeys = []) {
         if (toggleableKeys.length > 0) {
             toggleableKeys.forEach((_toggleableKey) => {
@@ -100,71 +66,83 @@ class Leaf {
                     parent: this,
                     belongTo: __classPrivateFieldGet(this, _Leaf_belongTo, "f")
                 }).grow(_toggleableKey.children);
-                __classPrivateFieldGet(this, _Leaf_children, "f").add(child);
+                __classPrivateFieldGet(this, _Leaf_children, "f").push(child);
             });
         }
         return this;
     }
-    rise(child, isToggled) {
-        var _a;
+    rise(toggledKeys) {
+        // if current key is toggled or children is all toggled
+        // just add current key into toggled keys
+        // else remove current key
+        const isToggled = toggledKeys.has(__classPrivateFieldGet(this, _Leaf_key, "f")) || __classPrivateFieldGet(this, _Leaf_children, "f").every((child) => toggledKeys.has(child.key));
+        const rised = new Set(toggledKeys);
         if (isToggled) {
-            __classPrivateFieldGet(this, _Leaf_toggledChildren, "f").add(child);
+            rised.add(__classPrivateFieldGet(this, _Leaf_key, "f"));
         }
         else {
-            __classPrivateFieldGet(this, _Leaf_toggledChildren, "f").delete(child);
+            rised.delete(__classPrivateFieldGet(this, _Leaf_key, "f"));
+        }
+        if (__classPrivateFieldGet(this, _Leaf_parent, "f")) {
+            return __classPrivateFieldGet(this, _Leaf_parent, "f").rise(rised);
         }
-        // if toggled state is same, stop
-        const _isToggled = __classPrivateFieldGet(this, _Leaf_children, "f").size === __classPrivateFieldGet(this, _Leaf_toggledChildren, "f").size;
-        const _hasToggled = !!__classPrivateFieldGet(this, _Leaf_belongTo, "f").toggledLeaves.has(this);
-        if (_hasToggled === _isToggled)
-            return;
-        this.toggleBy(_isToggled, true);
-        // rise to parent
-        (_a = __classPrivateFieldGet(this, _Leaf_parent, "f")) === null || _a === void 0 ? void 0 : _a.rise(this, _isToggled);
+        return rised;
     }
-    fall(isToggled) {
-        // if toggled state is same, stop
-        const _hasToggled = !!__classPrivateFieldGet(this, _Leaf_belongTo, "f").toggledLeaves.has(this);
-        if (_hasToggled === isToggled)
-            return;
-        this.toggleBy(isToggled, true);
-        // fall to every child
-        Array.from(__classPrivateFieldGet(this, _Leaf_children, "f").values()).forEach((child) => {
-            child.fall(isToggled);
-        });
+    fall(isToggled, toggledKeys) {
+        return __classPrivateFieldGet(this, _Leaf_children, "f").reduce((prev, leaf) => {
+            // deep loop, remove or add key
+            const fell = leaf.fall(isToggled, prev);
+            // toggle true, add key
+            // toggle false, remove key
+            if (isToggled) {
+                fell.add(__classPrivateFieldGet(this, _Leaf_key, "f"));
+            }
+            else {
+                fell.delete(__classPrivateFieldGet(this, _Leaf_key, "f"));
+            }
+            return fell;
+        }, new Set(toggledKeys));
     }
 }
-_Leaf_key = new WeakMap(), _Leaf_belongTo = new WeakMap(), _Leaf_parent = new WeakMap(), _Leaf_children = new WeakMap(), _Leaf_toggledChildren = new WeakMap();
+_Leaf_key = new WeakMap(), _Leaf_belongTo = new WeakMap(), _Leaf_parent = new WeakMap(), _Leaf_children = new WeakMap();
 /**
  * @description
  * toggle able
  */
-const useToggleable = (toggleableKeys, options = {}) => {
-    /// use once
-    const _isDefaultToggled = useRef(!!options.isDefaultToggled);
+const useToggleable = (toggleableKeys, _a = {}) => {
+    var { onToggle } = _a, options = __rest(_a, ["onToggle"]);
     /// re-create tree when toggleable keys changed
     const tree = useMemo(() => {
-        return toggleableKeys.reduce((_tree, toggleable) => _tree.grow(toggleable), new Tree({
-            isDefaultToggled: _isDefaultToggled.current
-        }));
+        return toggleableKeys.reduce((_tree, toggleable) => {
+            return _tree.grow(toggleable);
+        }, new Tree());
     }, [toggleableKeys]);
-    /// toggled keys
-    useEffect(() => {
-        if (!options.toggledKeys)
-            return;
-        tree.toggleWith(options.toggledKeys);
-    }, [options.toggledKeys]);
-    /// toggled keys
-    const _toggledKeys = useMemo(() => {
-        return new Set(Array.from(tree.toggledLeaves).map((leaf) => leaf.key));
-    }, [tree]);
+    /// use controlled state to record toggled keys
+    const [_toggledKeys, _setToggledKeys] = useControlledState(options.toggledKeys, {
+        defaultState: () => {
+            return options.isDefaultToggled
+                ? Array.from(Array.from(tree.groupedLeaves.values()).reduce((prev, leaves) => {
+                    leaves.forEach((leaf) => prev.add(leaf.key));
+                    return prev;
+                }, new Set()))
+                : [];
+        }
+    });
+    /// use set for toggled keys to make it read-only
+    const readableToggledKeys = useMemo(() => new Set(_toggledKeys), [_toggledKeys]);
     /// check current key is toggled
-    const isToggled = useCallback((key) => _toggledKeys.has(key), [tree]);
+    const isToggled = useCallback((key) => !readableToggledKeys || readableToggledKeys.has(key), [readableToggledKeys]);
     /// toggle one key
-    const toggle = useCallback((key) => tree.toggle(key), [tree]);
+    const toggle = useCallback((key) => {
+        // get new toggled keys by toggle current key
+        const _toggledKeys = Array.from(tree.toggle(key, readableToggledKeys));
+        // set state
+        _setToggledKeys(_toggledKeys);
+        // trigger on toggle callback
+        onToggle === null || onToggle === void 0 ? void 0 : onToggle(_toggledKeys);
+    }, [tree, readableToggledKeys, _setToggledKeys, onToggle]);
     return {
-        isAllToggled: tree.isAllToggled,
-        toggledKeys: _toggledKeys,
+        toggledKeys: readableToggledKeys,
         isToggled,
         toggle
     };

package/dist/index.d.ts

@@ -32,3 +32,10 @@ export { isMobile } from './is/is-mobile';
 export { isOverflow } from './is/is-overflow';
 export { isStyleElement } from './is/is-style-element';
 export { isFunction } from './is/is-function';
+/**
+ * @description
+ * utils
+ */
+export { type Nullable } from './utils/null-able';
+export { type Partialable } from './utils/partial-able';
+export { unique, uniqueBy } from './utils/unique';

package/dist/index.js

@@ -24,3 +24,4 @@ export { isMobile } from './is/is-mobile.js';
 export { isOverflow } from './is/is-overflow.js';
 export { isStyleElement } from './is/is-style-element.js';
 export { isFunction } from './is/is-function.js';
+export { unique, uniqueBy } from './utils/unique.js';

package/dist/node_modules/tslib/tslib.es6.js

@@ -1,3 +1,11 @@
+function __rest(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;
+}
 function __classPrivateFieldGet(receiver, state, kind, f) {
   if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
   if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -14,4 +22,4 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-export { __classPrivateFieldGet, __classPrivateFieldSet };
+export { __classPrivateFieldGet, __classPrivateFieldSet, __rest };

package/dist/utils/unique.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description
+ * unique
+ */
+export declare const unique: <T = unknown>(value: Iterable<T>) => T[];
+/**
+ * @description
+ * unique by
+ */
+export declare const uniqueBy: <T, P>(value: Iterable<T>, callback: (item: T) => P) => P[];

package/dist/utils/unique.js

@@ -0,0 +1,16 @@
+/**
+ * @description
+ * unique
+ */
+const unique = (value) => {
+    return Array.from(new Set(value));
+};
+/**
+ * @description
+ * unique by
+ */
+const uniqueBy = (value, callback) => {
+    return Array.from(new Set(Array.from(value).map(callback)));
+};
+
+export { unique, uniqueBy };

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.11-beta.5",
+  "version": "1.2.11-beta.6",
   "description": "react utils collection",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
-    "./dom": "./dist/dom/index.js",
-    "./types": "./dist/types/index.d.ts"
+    "./dom": "./dist/dom/index.js"
   },
   "scripts": {
     "dev": "rollup -c -w",

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export { Nullable } from './null-able';
-export { Partialable } from './partial-able';

package/dist/types/index.js

@@ -1 +0,0 @@
-