@weser/hooks 0.0.18 → 1.0.1

package/dist/useKeyDown.d.ts

@@ -1,5 +1,11 @@
 import { RefObject } from 'react';
 type Options = {
+    modifiers?: {
+        ctrl?: boolean;
+        meta?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+    };
     target?: RefObject<HTMLElement>;
     active?: boolean;
 };

package/dist/useKeyDown.js

@@ -1,22 +1,33 @@
 import { useEffect } from 'react';
 export default function useKeyDown(keyCode, callback, options = {}) {
-    const { active = true, target } = options;
+    const { active = true, target, modifiers = {} } = options;
+    const { ctrl = false, meta = false, alt = false, shift = false } = modifiers;
     const keyCodes = [].concat(keyCode);
     useEffect(() => {
         if (!active || target === null || target?.current === null) {
             return;
         }
         const hasRef = target && target.current;
-        const element = hasRef ? target.current : document;
+        const element = target?.current ?? document;
         if (element) {
-            const handleKeyDown = (e) => {
-                if (keyCodes.includes(e.code) &&
-                    (!hasRef || (hasRef && document.activeElement === element))) {
-                    callback(e);
-                }
+            const handleKeyDown = (event) => {
+                const e = event;
+                if (!keyCodes.includes(e.code))
+                    return;
+                if (hasRef && document.activeElement !== element)
+                    return;
+                if (ctrl && !e.ctrlKey)
+                    return;
+                if (meta && !e.metaKey)
+                    return;
+                if (alt && !e.altKey)
+                    return;
+                if (shift && !e.shiftKey)
+                    return;
+                callback(e);
             };
             element.addEventListener('keydown', handleKeyDown);
             return () => element.removeEventListener('keydown', handleKeyDown);
         }
-    }, [target, callback, active, keyCode]);
+    }, [options, callback, active]);
 }

package/dist/useList.d.ts

@@ -1,4 +1,4 @@
-export default function useList<T>(defaultList?: Array<T>): readonly [T[], {
+export default function useList<T>(initialList?: Array<T>): readonly [T[], {
     set: (list: Array<T>) => void;
     add: (item: T) => void;
     removeAt: (index: number) => void;

package/dist/useList.js

@@ -1,6 +1,6 @@
 import { useState } from 'react';
-export default function useList(defaultList = []) {
-    const [list, setList] = useState(defaultList);
+export default function useList(initialList = []) {
+    const [list, setList] = useState(initialList);
     function set(list) {
         setList(list);
     }

package/dist/useTree.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { type BaseNode, type BaseNodeInput } from '@weser/tree';
+export default function useTree<T extends BaseNode<T>>(initialTree: T): {
+    tree: T;
+    setTree: import("react").Dispatch<import("react").SetStateAction<T>>;
+    traverse: (callback: (node: T) => void) => void;
+    create: (node: T extends any ? Omit<T, "id"> : never) => T;
+    get: (id: string, rootNode?: T) => T | null;
+    clone: (id: string) => T | null;
+    getParent: (id: string) => T | null;
+    find: (condition: (node: T) => boolean) => T | null;
+    findAll: (condition: (node: T) => boolean) => T[];
+    update: (id: string, newNode: Partial<BaseNodeInput<T>>) => void;
+    replace: (id: string, newNode: T) => void;
+    remove: (id: string) => void;
+    add: (id: string, newNode: T) => void;
+    insert: (id: string, index: number, newNode: T) => void;
+    move: (id: string, parentId: string, index?: number) => void;
+};

package/dist/useTree.js

@@ -0,0 +1,24 @@
+import { useState } from 'react';
+import * as utils from '@weser/tree';
+export default function useTree(initialTree) {
+    const [tree, setTree] = useState(initialTree);
+    return {
+        tree,
+        setTree,
+        // helpers
+        traverse: (callback) => utils.traverse(tree, callback),
+        create: (utils.createNode),
+        get: (id, rootNode = tree) => utils.getNode(rootNode, id),
+        clone: (id) => utils.cloneNode(tree, id),
+        getParent: (id) => utils.getParentNode(tree, id),
+        find: (condition) => utils.findNode(tree, condition),
+        findAll: (condition) => utils.findAllNode(tree, condition),
+        // actions
+        update: (id, newNode) => setTree((tree) => utils.updateNode(tree, id, newNode)),
+        replace: (id, newNode) => setTree((tree) => utils.replaceNode(tree, id, newNode)),
+        remove: (id) => setTree((tree) => utils.removeNode(tree, id)),
+        add: (id, newNode) => setTree((tree) => utils.addNode(tree, id, newNode)),
+        insert: (id, index, newNode) => setTree((tree) => utils.insertNode(tree, id, index, newNode)),
+        move: (id, parentId, index) => setTree((tree) => utils.moveNode(tree, id, parentId, index)),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weser/hooks",
-  "version": "0.0.18",
+  "version": "1.0.1",
   "description": "React hooks for building apps",
   "author": "Robin Weser <robin@weser.io>",
   "license": "MIT",
@@ -42,6 +42,9 @@
     "hooks",
     "utils"
   ],
+  "dependencies": {
+    "@weser/tree": "1.0.0"
+  },
   "peerDependencies": {
     "react": ">16.3.0"
   },
@@ -52,5 +55,5 @@
     "rimraf": "^3.0.2",
     "typescript": "^5.4.5"
   },
-  "gitHead": "4dd312c8cf505d0c06d25ca489b893a6c6c0d9fe"
+  "gitHead": "e985ef20f1fb441a5fbdc4e5beb54ddea728f95f"
 }