@weser/hooks 0.0.17 → 1.0.0

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/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;
+    createNode: (node: T extends any ? Omit<T, "id"> : never) => T;
+    getNode: (id: string, rootNode?: T) => T | null;
+    cloneNode: (id: string) => T | null;
+    getParentNode: (id: string) => T | null;
+    findNode: (condition: (node: T) => boolean) => T | null;
+    findAllNode: (condition: (node: T) => boolean) => T[];
+    updateNode: (id: string, newNode: Partial<BaseNodeInput<T>>) => void;
+    replaceNode: (id: string, newNode: T) => void;
+    removeNode: (id: string) => void;
+    addNode: (id: string, newNode: T) => void;
+    insertNode: (id: string, index: number, newNode: T) => void;
+    moveNode: (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),
+        createNode: (utils.createNode),
+        getNode: (id, rootNode = tree) => utils.getNode(rootNode, id),
+        cloneNode: (id) => utils.cloneNode(tree, id),
+        getParentNode: (id) => utils.getParentNode(tree, id),
+        findNode: (condition) => utils.findNode(tree, condition),
+        findAllNode: (condition) => utils.findAllNode(tree, condition),
+        // actions
+        updateNode: (id, newNode) => setTree((tree) => utils.updateNode(tree, id, newNode)),
+        replaceNode: (id, newNode) => setTree((tree) => utils.replaceNode(tree, id, newNode)),
+        removeNode: (id) => setTree((tree) => utils.removeNode(tree, id)),
+        addNode: (id, newNode) => setTree((tree) => utils.addNode(tree, id, newNode)),
+        insertNode: (id, index, newNode) => setTree((tree) => utils.insertNode(tree, id, index, newNode)),
+        moveNode: (id, parentId, index) => setTree((tree) => utils.moveNode(tree, id, parentId, index)),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weser/hooks",
-  "version": "0.0.17",
+  "version": "1.0.0",
   "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": "71b258e9fc17ff82728fc3b51ac935f48b11f204"
+  "gitHead": "afc0628ca4aeaba255eef9716652640fdc5b50c4"
 }