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

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

@@ -1,18 +1,44 @@
 import { Key } from 'react';
-type Dependencies = {
-    keys?: Key[];
-    isAllDefaultToggled?: boolean;
+/**
+ * @description
+ * toggleable key
+ */
+type ToggleableKey = {
+    /**
+     * @description
+     * unique key
+     */
+    key: Key;
+    /**
+     * @description
+     * children
+     */
+    children?: ToggleableKey[];
+};
+/**
+ * @description
+ * extra options
+ */
+type Options = {
+    /**
+     * @description
+     * default toggled
+     */
+    isDefaultToggled?: boolean;
+    /**
+     * @description
+     * toggled keys
+     */
+    toggledKeys?: Key[];
 };
 /**
  * @description
  * toggle able
  */
-export declare const useToggleable: ({ keys, isAllDefaultToggled }?: Dependencies) => {
-    toggleBy: (key: Key, isToggled: boolean) => void;
-    toggle: (key: Key) => void;
-    toggleAll: () => void;
-    isToggled: (key: Key) => boolean;
-    toggledKeys: Map<Key, true>;
+export declare const useToggleable: (toggleableKeys: ToggleableKey[], options?: Options) => {
     isAllToggled: boolean;
+    toggledKeys: Set<Key>;
+    isToggled: (key: Key) => boolean;
+    toggle: (key: Key) => void;
 };
 export {};

package/dist/hooks/use-toggleable.js

@@ -1,55 +1,172 @@
-import { useState, useCallback, useMemo } from 'react';
+import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.js';
+import { useRef, useMemo, useEffect, useCallback } from 'react';
 
-/**
- * @description
- * toggle able
- */
-const useToggleable = ({ keys, isAllDefaultToggled } = {}) => {
-    const [toggledKeys, setToggledKeys] = useState(() => {
-        if (isAllDefaultToggled) {
-            return new Map(keys === null || keys === void 0 ? void 0 : keys.map((key) => [key, true]));
+var _Tree_leaves, _Tree_toggledLeaves, _Tree_groupedLeaves, _Tree_isDefaultToggled, _Leaf_key, _Leaf_belongTo, _Leaf_parent, _Leaf_children, _Leaf_toggledChildren;
+class Tree {
+    constructor({ isDefaultToggled }) {
+        _Tree_leaves.set(this, void 0);
+        _Tree_toggledLeaves.set(this, void 0);
+        _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({
+            key: toggleableKey.key,
+            parent: null,
+            belongTo: this
+        }).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);
+        });
+    }
+    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);
+            });
+        });
+    }
+}
+_Tree_leaves = new WeakMap(), _Tree_toggledLeaves = new WeakMap(), _Tree_groupedLeaves = new WeakMap(), _Tree_isDefaultToggled = 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");
+        // 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);
         }
-        return new Map();
-    });
-    /// toggle by flag
-    const toggleBy = useCallback((key, isToggled) => {
-        setToggledKeys((prev) => {
-            if (isToggled) {
-                return new Map(prev).set(key, true);
-            }
-            const _toggledKeys = new Map(prev);
-            _toggledKeys.delete(key);
-            return _toggledKeys;
+        if (isPrevent)
+            return;
+        // fall to every child
+        Array.from(__classPrivateFieldGet(this, _Leaf_children, "f").values()).forEach((child) => {
+            child.fall(isToggled);
         });
-    }, []);
-    /// if all key is toggled
-    const isAllToggled = useMemo(() => {
-        return toggledKeys.size === (keys === null || keys === void 0 ? void 0 : keys.length);
-    }, [toggledKeys, keys]);
-    /// is toggled
-    const isToggled = useCallback((key) => {
-        return toggledKeys.has(key);
-    }, [toggledKeys]);
-    /// toggle
-    const toggle = useCallback((key) => {
-        toggleBy(key, !isToggled(key));
-    }, [toggleBy, isToggled]);
-    /// toggle all
-    const toggleAll = useCallback(() => {
-        if (isAllToggled) {
-            setToggledKeys(new Map());
+        // 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) => {
+                const child = new Leaf({
+                    key: _toggleableKey.key,
+                    parent: this,
+                    belongTo: __classPrivateFieldGet(this, _Leaf_belongTo, "f")
+                }).grow(_toggleableKey.children);
+                __classPrivateFieldGet(this, _Leaf_children, "f").add(child);
+            });
+        }
+        return this;
+    }
+    rise(child, isToggled) {
+        var _a;
+        if (isToggled) {
+            __classPrivateFieldGet(this, _Leaf_toggledChildren, "f").add(child);
         }
         else {
-            setToggledKeys(new Map(keys === null || keys === void 0 ? void 0 : keys.map((key) => [key, true])));
+            __classPrivateFieldGet(this, _Leaf_toggledChildren, "f").delete(child);
         }
-    }, [isAllToggled, keys]);
+        // 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);
+    }
+    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);
+        });
+    }
+}
+_Leaf_key = new WeakMap(), _Leaf_belongTo = new WeakMap(), _Leaf_parent = new WeakMap(), _Leaf_children = new WeakMap(), _Leaf_toggledChildren = new WeakMap();
+/**
+ * @description
+ * toggle able
+ */
+const useToggleable = (toggleableKeys, options = {}) => {
+    /// use once
+    const _isDefaultToggled = useRef(!!options.isDefaultToggled);
+    /// re-create tree when toggleable keys changed
+    const tree = useMemo(() => {
+        return toggleableKeys.reduce((_tree, toggleable) => _tree.grow(toggleable), new Tree({
+            isDefaultToggled: _isDefaultToggled.current
+        }));
+    }, [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]);
+    /// check current key is toggled
+    const isToggled = useCallback((key) => _toggledKeys.has(key), [tree]);
+    /// toggle one key
+    const toggle = useCallback((key) => tree.toggle(key), [tree]);
     return {
-        toggleBy,
-        toggle,
-        toggleAll,
+        isAllToggled: tree.isAllToggled,
+        toggledKeys: _toggledKeys,
         isToggled,
-        toggledKeys,
-        isAllToggled
+        toggle
     };
 };
 

package/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -0,0 +1 @@
+

package/dist/types/null-able.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * null able
+ */
+export type Nullable<T> = T | null;

package/dist/types/partial-able.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * partial able
+ */
+export type Partialable<T> = T | undefined;

package/package.json

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