@weser/tree 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-present Robin Weser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @weser/loops
+
+[Documentation](https://packages.weser.io/loops)

package/dist/addNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function addNode<T extends BaseNode<T>>(rootNode: T, id: string, newNode: T): T;

package/dist/addNode.js

@@ -0,0 +1,9 @@
+import getNode from './getNode.js';
+import insertNode from './insertNode.js';
+export default function addNode(rootNode, id, newNode) {
+    const parentNode = getNode(rootNode, id);
+    if (!parentNode || !parentNode.children) {
+        return rootNode;
+    }
+    return insertNode(rootNode, id, parentNode.children.length, newNode);
+}

package/dist/arrayEach.d.ts

@@ -0,0 +1 @@
+export default function arrayEach<T>(arr: Array<T>, iterator: (value: T, index: number, length: number, array: Array<T>) => void): void;

package/dist/arrayEach.js

@@ -0,0 +1,5 @@
+export default function arrayEach(arr, iterator) {
+    for (let i = 0, len = arr.length; i < len; ++i) {
+        iterator(arr[i], i, len, arr);
+    }
+}

package/dist/arrayFilter.d.ts

@@ -0,0 +1 @@
+export default function arrayFilter<T>(arr: Array<T>, filter: (value: T, index: number, length: number, array: Array<T>) => boolean): T[];

package/dist/arrayFilter.js

@@ -0,0 +1,10 @@
+export default function arrayFilter(arr, filter) {
+    const filteredArr = [];
+    for (let i = 0, len = arr.length; i < len; ++i) {
+        const value = arr[i];
+        if (filter(value, i, len, arr)) {
+            filteredArr.push(value);
+        }
+    }
+    return filteredArr;
+}

package/dist/arrayGroupBy.d.ts

@@ -0,0 +1 @@
+export default function arrayGroupBy<T extends Record<string, any>>(arr: Array<T>, key: keyof T | ((item: T) => string)): Record<string, T[]>;

package/dist/arrayGroupBy.js

@@ -0,0 +1,8 @@
+export default function arrayGroupBy(arr, key) {
+    return arr.reduce((grouped, item) => {
+        const group = typeof key === 'function' ? key(item) : item[key];
+        grouped[group] = grouped[group] || [];
+        grouped[group].push(item);
+        return grouped;
+    }, {});
+}

package/dist/arrayMap.d.ts

@@ -0,0 +1 @@
+export default function arrayMap<T>(arr: Array<T>, mapper: (value: T, index: number, length: number, array: Array<T>) => any): any[];

package/dist/arrayMap.js

@@ -0,0 +1,7 @@
+export default function arrayMap(arr, mapper) {
+    const mappedArr = [];
+    for (let i = 0, len = arr.length; i < len; ++i) {
+        mappedArr.push(mapper(arr[i], i, len, arr));
+    }
+    return mappedArr;
+}

package/dist/arrayReduce.d.ts

@@ -0,0 +1 @@
+export default function arrayReduce<T, B>(arr: Array<T>, reducer: (accumulator: B, value: T, index: number, length: number, array: Array<T>) => B, initialValue: B): B;

package/dist/arrayReduce.js

@@ -0,0 +1,6 @@
+export default function arrayReduce(arr, reducer, initialValue) {
+    for (let i = 0, len = arr.length; i < len; ++i) {
+        initialValue = reducer(initialValue, arr[i], i, len, arr);
+    }
+    return initialValue;
+}

package/dist/cloneNode.d.ts

@@ -0,0 +1,2 @@
+import { BaseNode } from './types';
+export default function cloneNode<T extends BaseNode<T>>(rootNode: T, id: string): T | null;

package/dist/cloneNode.js

@@ -0,0 +1,22 @@
+import getNode from './getNode';
+export default function cloneNode(rootNode, id) {
+    const node = getNode(rootNode, id);
+    if (!node) {
+        return null;
+    }
+    return cloneNodeById(node);
+}
+function cloneNodeById(node) {
+    if (!node.children || node.children.length === 0) {
+        return {
+            ...node,
+            id: crypto.randomUUID(),
+        };
+    }
+    const newChildren = node.children.map(cloneNodeById);
+    return {
+        ...node,
+        id: crypto.randomUUID(),
+        children: newChildren,
+    };
+}

package/dist/createNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode, type BaseNodeInput } from './types.js';
+export default function createNode<T extends BaseNode<T>>(node: BaseNodeInput<T>): T;

package/dist/createNode.js

@@ -0,0 +1,7 @@
+export default function createNode(node) {
+    const id = crypto.randomUUID();
+    return {
+        ...node,
+        id,
+    };
+}

package/dist/findAllNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function findAllNode<T extends BaseNode<T>>(rootNode: T, condition: (node: T) => boolean): Array<T>;

package/dist/findAllNode.js

@@ -0,0 +1,12 @@
+export default function findAllNode(rootNode, condition) {
+    const nodes = [];
+    if (condition(rootNode)) {
+        nodes.push(rootNode);
+    }
+    if (rootNode.children) {
+        for (const node of rootNode.children) {
+            nodes.push(...findAllNode(node, condition));
+        }
+    }
+    return nodes;
+}

package/dist/findNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function findNode<T extends BaseNode<T>>(rootNode: T, condition: (node: T) => boolean): T | null;

package/dist/findNode.js

@@ -0,0 +1,14 @@
+export default function findNode(rootNode, condition) {
+    if (condition(rootNode)) {
+        return rootNode;
+    }
+    if (rootNode.children) {
+        for (const node of rootNode.children) {
+            const result = findNode(node, condition);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return null;
+}

package/dist/getNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function getNode<T extends BaseNode<T>>(rootNode: T, id: string): T | null;

package/dist/getNode.js

@@ -0,0 +1,14 @@
+export default function getNode(rootNode, id) {
+    if (rootNode.id === id) {
+        return rootNode;
+    }
+    if (rootNode.children) {
+        for (const node of rootNode.children) {
+            const result = getNode(node, id);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return null;
+}

package/dist/getParentNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function getParentNode<T extends BaseNode<T>>(rootNode: T, id: string): T | null;

package/dist/getParentNode.js

@@ -0,0 +1,4 @@
+import findNode from './findNode.js';
+export default function getParentNode(rootNode, id) {
+    return findNode(rootNode, (node) => Boolean(node.children && node.children.find((node) => node.id === id)));
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { default as addNode } from './addNode.js';
+export { default as cloneNode } from './cloneNode.js';
+export { default as createNode } from './createNode.js';
+export { default as findNode } from './findNode.js';
+export { default as findAllNode } from './findAllNode.js';
+export { default as getNode } from './getNode.js';
+export { default as getParentNode } from './getParentNode.js';
+export { default as insertNode } from './insertNode.js';
+export { default as moveNode } from './moveNode.js';
+export { default as removeNode } from './removeNode.js';
+export { default as replaceNode } from './replaceNode.js';
+export { default as traverse } from './traverse.js';
+export { default as updateNode } from './updateNode.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+export { default as addNode } from './addNode.js';
+export { default as cloneNode } from './cloneNode.js';
+export { default as createNode } from './createNode.js';
+export { default as findNode } from './findNode.js';
+export { default as findAllNode } from './findAllNode.js';
+export { default as getNode } from './getNode.js';
+export { default as getParentNode } from './getParentNode.js';
+export { default as insertNode } from './insertNode.js';
+export { default as moveNode } from './moveNode.js';
+export { default as removeNode } from './removeNode.js';
+export { default as replaceNode } from './replaceNode.js';
+export { default as traverse } from './traverse.js';
+export { default as updateNode } from './updateNode.js';
+export * from './types.js';

package/dist/insertNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function insertNode<T extends BaseNode<T>>(rootNode: T, id: string, index: number, newNode: T): T;

package/dist/insertNode.js

@@ -0,0 +1,17 @@
+import getNode from './getNode.js';
+import replaceNode from './replaceNode.js';
+export default function insertNode(rootNode, id, index, newNode) {
+    const parentNode = getNode(rootNode, id);
+    if (!parentNode || !parentNode.children) {
+        return rootNode;
+    }
+    const children = [
+        ...parentNode.children.slice(0, index),
+        newNode,
+        ...parentNode.children.slice(index),
+    ];
+    return replaceNode(rootNode, id, {
+        ...parentNode,
+        children,
+    });
+}

package/dist/invariant.d.ts

@@ -0,0 +1 @@
+export default function invariant(condition: boolean, message: string): void;

package/dist/invariant.js

@@ -0,0 +1,5 @@
+export default function invariant(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}

package/dist/moveNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function moveNode<T extends BaseNode<T>>(rootNode: T, id: string, parentId: string, index?: number): T;

package/dist/moveNode.js

@@ -0,0 +1,12 @@
+import getNode from './getNode.js';
+import insertNode from './insertNode.js';
+import removeNode from './removeNode.js';
+export default function moveNode(rootNode, id, parentId, index) {
+    const node = getNode(rootNode, id);
+    const parentNode = getNode(rootNode, parentId);
+    if (!node || !parentNode || !parentNode.children) {
+        return rootNode;
+    }
+    const removedNode = removeNode(rootNode, id);
+    return insertNode(removedNode, parentId, index ?? parentNode.children.length, node);
+}

package/dist/objectEach.d.ts

@@ -0,0 +1 @@
+export default function objectEach<T extends Record<PropertyKey, any>>(obj: T, iterator: (value: T[keyof T], key: keyof T, obj: T) => void): void;

package/dist/objectEach.js

@@ -0,0 +1,5 @@
+export default function objectEach(obj, iterator) {
+    for (const key in obj) {
+        iterator(obj[key], key, obj);
+    }
+}

package/dist/objectFilter.d.ts

@@ -0,0 +1 @@
+export default function objectFilter<T extends Record<PropertyKey, any>>(obj: T, filter: (value: T[keyof T], key: keyof T, obj: T) => boolean): {};

package/dist/objectFilter.js

@@ -0,0 +1,11 @@
+export default function objectFilter(obj, filter) {
+    const filteredObj = {};
+    for (const key in obj) {
+        const value = obj[key];
+        if (filter(value, key, obj)) {
+            // @ts-ignore
+            filteredObj[key] = value;
+        }
+    }
+    return filteredObj;
+}

package/dist/objectFind.d.ts

@@ -0,0 +1 @@
+export default function objectFind<T extends Record<PropertyKey, any>>(obj: T, query: (value: T[keyof T], key: keyof T, obj: T) => boolean): Extract<keyof T, string> | undefined;

package/dist/objectFind.js

@@ -0,0 +1,7 @@
+export default function objectFind(obj, query) {
+    for (const key in obj) {
+        if (query(obj[key], key, obj)) {
+            return key;
+        }
+    }
+}

package/dist/objectKeys.d.ts

@@ -0,0 +1 @@
+export default function objectKeys<T extends Record<string, any>>(object: T): Array<keyof T>;

package/dist/objectKeys.js

@@ -0,0 +1,3 @@
+export default function objectKeys(object) {
+    return Object.keys(object);
+}

package/dist/objectMap.d.ts

@@ -0,0 +1 @@
+export default function objectMap<T extends Record<PropertyKey, any>, R>(obj: T, mapper: <K extends keyof T>(value: T[K], key: K, obj: T) => R): Record<keyof T, R>;

package/dist/objectMap.js

@@ -0,0 +1,8 @@
+export default function objectMap(obj, mapper) {
+    const mappedObj = {};
+    for (const key in obj) {
+        // @ts-ignore
+        mappedObj[key] = mapper(obj[key], key, obj);
+    }
+    return mappedObj;
+}

package/dist/objectMergeDeep.d.ts

@@ -0,0 +1 @@
+export default function objectMergeDeep<T extends Record<PropertyKey, any>>(base: T, ...objs: Array<T>): T;

package/dist/objectMergeDeep.js

@@ -0,0 +1,20 @@
+export default function objectMergeDeep(base, ...objs) {
+    for (let i = 0, len = objs.length; i < len; ++i) {
+        const obj = objs[i];
+        for (const key in obj) {
+            // see https://github.com/robinweser/fast-loops/issues/18
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                continue;
+            }
+            const value = obj[key];
+            if (typeof value === 'object' &&
+                !Array.isArray(value) &&
+                value !== null) {
+                base[key] = objectMergeDeep(base[key], value);
+                continue;
+            }
+            base[key] = value;
+        }
+    }
+    return base;
+}

package/dist/objectReduce.d.ts

@@ -0,0 +1 @@
+export default function objectReduce<T extends Record<PropertyKey, any>, B>(obj: T, reducer: (accumulator: B, value: T[keyof T], key: keyof T, obj: T) => B, initialValue: B): B;

package/dist/objectReduce.js

@@ -0,0 +1,6 @@
+export default function objectReduce(obj, reducer, initialValue) {
+    for (const key in obj) {
+        initialValue = reducer(initialValue, obj[key], key, obj);
+    }
+    return initialValue;
+}

package/dist/removeNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function removeNode<T extends BaseNode<T>>(rootNode: T, id: string): T;

package/dist/removeNode.js

@@ -0,0 +1,14 @@
+import { arrayMap, arrayFilter } from '@weser/loops';
+export default function removeNode(rootNode, id) {
+    return removeNodeById(rootNode, id);
+}
+function removeNodeById(rootNode, id) {
+    if (!rootNode.children || rootNode.children.length === 0) {
+        return rootNode;
+    }
+    const children = arrayMap(arrayFilter(rootNode.children, (node) => node.id !== id), (node) => removeNodeById(node, id));
+    return {
+        ...rootNode,
+        children,
+    };
+}

package/dist/replaceNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function replaceNode<T extends BaseNode<T>>(rootNode: T, id: string, newNode: T): T;

package/dist/replaceNode.js

@@ -0,0 +1,21 @@
+import getNode from './getNode.js';
+export default function replaceNode(rootNode, id, newNode) {
+    const node = getNode(rootNode, id);
+    if (!node) {
+        return rootNode;
+    }
+    return replaceNodeById(rootNode, id, newNode);
+}
+function replaceNodeById(rootNode, id, newNode) {
+    if (rootNode.id === id) {
+        return newNode;
+    }
+    if (!rootNode.children || rootNode.children.length === 0) {
+        return rootNode;
+    }
+    const children = rootNode.children.map((node) => replaceNodeById(node, id, newNode));
+    return {
+        ...rootNode,
+        children,
+    };
+}

package/dist/traverse.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode } from './types.js';
+export default function traverse<T extends BaseNode<T>>(rootNode: T, callback: (node: T) => void, type?: 'top-down' | 'bottom-up'): void;

package/dist/traverse.js

@@ -0,0 +1,12 @@
+import { arrayEach } from '@weser/loops';
+export default function traverse(rootNode, callback, type = 'top-down') {
+    if (type === 'top-down') {
+        callback(rootNode);
+    }
+    if (rootNode.children) {
+        arrayEach(rootNode.children, (node) => traverse(node, callback, type));
+    }
+    if (type === 'bottom-up') {
+        callback(rootNode);
+    }
+}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/addnode.ts","../src/clonenode.ts","../src/createnode.ts","../src/findallnode.ts","../src/findnode.ts","../src/getnode.ts","../src/getparentnode.ts","../src/index.ts","../src/insertnode.ts","../src/movenode.ts","../src/removenode.ts","../src/replacenode.ts","../src/traverse.ts","../src/types.ts","../src/updatenode.ts"],"version":"5.9.2"}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+export type BaseNode<T> = {
+    id: string;
+    children: Array<T> | null;
+};
+export type BaseNodeInput<T> = DistributiveOmit<T, 'id'>;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/updateNode.d.ts

@@ -0,0 +1,2 @@
+import { type BaseNode, type BaseNodeInput } from './types.js';
+export default function updateNode<T extends BaseNode<T>>(rootNode: T, id: string, newNode: Partial<BaseNodeInput<T>>): T;

package/dist/updateNode.js

@@ -0,0 +1,12 @@
+import getNode from './getNode.js';
+import replaceNode from './replaceNode.js';
+export default function updateNode(rootNode, id, newNode) {
+    const node = getNode(rootNode, id);
+    if (!node) {
+        return rootNode;
+    }
+    return replaceNode(rootNode, id, {
+        ...node,
+        ...newNode,
+    });
+}

package/dist/useAction.d.ts

@@ -0,0 +1,12 @@
+export type T_ActionResponse<T = any> = T extends any ? [string] | [null, T?] : [string] | [null, T];
+type State<T> = {
+    loading: boolean;
+    data?: T | null;
+    error: string | null;
+};
+type T_ActionConfig<T> = {
+    onSuccess?: (data?: T) => void;
+    onError?: (error: string) => void;
+};
+export default function useAction<T, P extends Array<any>>(action: (...payload: P) => Promise<T_ActionResponse<T>>, config?: T_ActionConfig<T>): [State<T>, (...payload: P) => void];
+export {};

package/dist/useAction.js

@@ -0,0 +1,40 @@
+import { useState } from 'react';
+const initialState = {
+    loading: false,
+    data: null,
+    error: null,
+};
+export default function useAction(action, config = {}) {
+    const { onSuccess, onError } = config;
+    const [state, setState] = useState(initialState);
+    async function run(...payload) {
+        setState({
+            ...state,
+            loading: true,
+        });
+        const [error, data] = await action(...payload);
+        if (error !== null) {
+            if (onError) {
+                onError(error);
+            }
+            setState({
+                ...state,
+                error,
+                data: null,
+                loading: false,
+            });
+        }
+        else {
+            if (onSuccess) {
+                onSuccess(data);
+            }
+            setState({
+                ...state,
+                error: null,
+                data,
+                loading: false,
+            });
+        }
+    }
+    return [state, run];
+}

package/dist/useClickAway.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export default function useClickAway(ref: RefObject<HTMLElement | null>, callback: () => void, active?: boolean): void;

package/dist/useClickAway.js

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+export default function useClickAway(ref, callback, active = true) {
+    useEffect(() => {
+        const onClickAway = (e) => {
+            if (active && ref.current) {
+                const isClickOnInner = ref.current.contains(e.target);
+                if (!isClickOnInner) {
+                    setTimeout(callback, 0);
+                }
+            }
+        };
+        document.addEventListener('mousedown', onClickAway);
+        document.addEventListener('touchstart', onClickAway);
+        return () => {
+            document.removeEventListener('mousedown', onClickAway);
+            document.removeEventListener('touchstart', onClickAway);
+        };
+    }, [ref, active, callback]);
+}

package/dist/useClientOnly.d.ts

@@ -0,0 +1 @@
+export default function useClientSide(): boolean;

package/dist/useClientOnly.js

@@ -0,0 +1,6 @@
+import { useEffect, useState } from 'react';
+export default function useClientSide() {
+    const [isClientSide, setClientSide] = useState(false);
+    useEffect(() => setClientSide(true), []);
+    return isClientSide;
+}

package/dist/useDisclosure.d.ts

@@ -0,0 +1,16 @@
+export default function useDisclosure(defaultExpanded?: boolean): {
+    toggleProps: {
+        id: string;
+        onClick: void;
+        type: string;
+        'aria-expanded': boolean;
+        'aria-controls': string;
+    };
+    contentProps: {
+        id: string;
+        'aria-hidden': boolean;
+        'aria-labelledby': string;
+    };
+    isExpanded: boolean;
+    toggle: void;
+};

package/dist/useDisclosure.js

@@ -0,0 +1,25 @@
+import { useState, useEffect, useId } from 'react';
+export default function useDisclosure(defaultExpanded = false) {
+    const [isExpanded, setExpanded] = useState(defaultExpanded);
+    const id = useId();
+    useEffect(() => setExpanded(defaultExpanded), [defaultExpanded]);
+    const toggle = setExpanded((isExpanded) => !isExpanded);
+    const toggleProps = {
+        id: id + '-toggle',
+        onClick: toggle,
+        type: 'button',
+        'aria-expanded': isExpanded,
+        'aria-controls': id + '-content',
+    };
+    const contentProps = {
+        id: id + '-content',
+        'aria-hidden': !isExpanded,
+        'aria-labelledby': id + '-toggle',
+    };
+    return {
+        toggleProps,
+        contentProps,
+        isExpanded,
+        toggle,
+    };
+}

package/dist/useFocusTrap.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+type Config = {
+    visible?: boolean;
+    autoFocus?: boolean;
+};
+export default function useFocusTrap(ref: RefObject<HTMLElement | null>, active: boolean, config?: Config): void;
+export {};

package/dist/useFocusTrap.js

@@ -0,0 +1,77 @@
+import { useEffect } from 'react';
+import useKeyDown from './useKeyDown.js';
+const focusableSelector = `:is(
+  a[href], 
+  area[href], 
+  input:not([disabled]), 
+  select:not([disabled]), 
+  textarea:not([disabled]), 
+  button:not([disabled]), 
+  [tabindex]:not([tabindex="-1"]), 
+  [contenteditable]
+)`;
+export default function useFocusTrap(ref, active, config = {}) {
+    const { visible, autoFocus = true } = config;
+    useKeyDown('Tab', (e) => {
+        const element = ref.current;
+        if (!active || !element) {
+            return;
+        }
+        const focusables = [
+            ...element.querySelectorAll(focusableSelector),
+        ].filter((el) => el.hasAttribute('tabindex')
+            ? el.getAttribute('tabindex') !== '-1'
+            : true);
+        const firstFocusable = focusables[0];
+        const lastFocusable = focusables[focusables.length - 1];
+        const activeElement = document.activeElement;
+        let nextElement;
+        if (activeElement && focusables.includes(activeElement)) {
+            const index = focusables.indexOf(activeElement);
+            if (e.shiftKey) {
+                if (index === 0) {
+                    nextElement = lastFocusable;
+                }
+            }
+            else {
+                if (index === focusables.length - 1) {
+                    nextElement = firstFocusable;
+                }
+            }
+        }
+        else {
+            if (e.shiftKey) {
+                nextElement = lastFocusable;
+            }
+            else {
+                nextElement = firstFocusable;
+            }
+        }
+        if (nextElement) {
+            ;
+            nextElement.focus();
+            e.preventDefault();
+        }
+    }, {
+        active,
+    });
+    useEffect(() => {
+        const element = ref.current;
+        if (!autoFocus || !visible || !element) {
+            return;
+        }
+        const autoFocusElement = element.querySelector('[data-autofocus="true"]' + focusableSelector);
+        if (autoFocusElement) {
+            // @ts-ignore
+            autoFocusElement.focus();
+            return;
+        }
+        const nodeList = element.querySelectorAll(focusableSelector);
+        const elements = Array.from(nodeList);
+        const focusableElements = elements.filter((element) => !element.hasAttribute('tabindex') ||
+            element.getAttribute('tabindex') === '0');
+        // 1. focus the first focusable
+        // @ts-ignore, TODO: fix typing
+        focusableElements[0]?.focus();
+    }, [visible, ref, autoFocus]);
+}

package/dist/useKeyDown.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+type Options = {
+    target?: RefObject<HTMLElement>;
+    active?: boolean;
+};
+export default function useKeyDown(keyCode: string | Array<string>, callback: (e: KeyboardEvent) => void, options?: Options): void;
+export {};

package/dist/useKeyDown.js

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

package/dist/useRouteChange.d.ts

@@ -0,0 +1 @@
+export default function useRouteChange(onRouteChange: (path: string) => void, pathname?: string): void;

package/dist/useRouteChange.js

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+export default function useRouteChange(onRouteChange, pathname) {
+    useEffect(() => {
+        if (pathname) {
+            onRouteChange(pathname);
+        }
+    }, [pathname]);
+    // track clicks on links with the current path
+    useEffect(() => {
+        const onClick = (e) => {
+            const target = e.target;
+            if (target.tagName === 'A' && target.href === pathname) {
+                onRouteChange(pathname);
+            }
+        };
+        window.addEventListener('click', onClick);
+        return () => window.removeEventListener('click', onClick);
+    }, []);
+}

package/dist/useScrollBlocking.d.ts

@@ -0,0 +1 @@
+export default function useScrollBlocking(active: boolean): void;

package/dist/useScrollBlocking.js

@@ -0,0 +1,28 @@
+import { useEffect } from 'react';
+let scrollTop;
+function blockScrolling(scrollElement) {
+    scrollTop = window.scrollY;
+    scrollElement.style.overflow = 'hidden';
+    scrollElement.style.position = 'fixed';
+    scrollElement.style.width = '100%';
+    scrollElement.style.top = -scrollTop + 'px';
+}
+function enableScrolling(scrollElement) {
+    scrollElement.style.removeProperty('position');
+    scrollElement.style.removeProperty('overflow');
+    scrollElement.style.removeProperty('top');
+    scrollElement.style.removeProperty('width');
+    window.scrollTo(0, scrollTop);
+}
+function toggleScrolling(isBlocked) {
+    const scrollElement = document.scrollingElement;
+    if (isBlocked) {
+        blockScrolling(scrollElement);
+    }
+    else {
+        enableScrolling(scrollElement);
+    }
+}
+export default function useScrollBlocking(active) {
+    useEffect(() => toggleScrolling(active), [active]);
+}

package/dist/useTrigger.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+type Props = {
+    defaultVisible?: boolean;
+    getTrigger?: () => HTMLElement | null;
+};
+export default function useTrigger({ defaultVisible, getTrigger, }?: Props): [boolean, (visible: boolean) => void, RefObject<HTMLElement>];
+export {};

package/dist/useTrigger.js

@@ -0,0 +1,24 @@
+import { useEffect, useRef, useState } from 'react';
+export default function useTrigger({ defaultVisible = false, getTrigger, } = {}) {
+    const triggerRef = useRef(null);
+    const [isVisible, _setVisible] = useState(false);
+    function getTriggerElement() {
+        if (getTrigger) {
+            return getTrigger();
+        }
+        return triggerRef.current;
+    }
+    function setVisible(visible) {
+        if (isVisible !== visible) {
+            _setVisible(visible);
+            if (!visible) {
+                const trigger = getTriggerElement();
+                if (trigger) {
+                    trigger.focus();
+                }
+            }
+        }
+    }
+    useEffect(() => _setVisible(defaultVisible), [defaultVisible]);
+    return [isVisible, setVisible, triggerRef];
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@weser/tree",
+  "version": "1.0.0",
+  "description": "Tiny helpers for working with tree data structure",
+  "author": "Robin Weser <robin@weser.io>",
+  "license": "MIT",
+  "homepage": "https://github.com/robinweser/weser.git",
+  "repository": "https://github.com/robinweser/weser.git",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/**"
+  ],
+  "browserslist": [
+    "IE >= 11",
+    "Firefox >= 60",
+    "Safari >= 11.1",
+    "Chrome >= 66",
+    "ChromeAndroid >= 66",
+    "iOS >= 11.3",
+    "Edge >= 15"
+  ],
+  "scripts": {
+    "setup": "pnpm build",
+    "clean": "rimraf dist",
+    "build": "tsc -b",
+    "dev": "pnpm build -w",
+    "test": "echo 1"
+  },
+  "keywords": [
+    "tree",
+    "data structure",
+    "utils"
+  ],
+  "dependencies": {
+    "@weser/loops": "^1.0.0"
+  },
+  "devDependencies": {
+    "ava": "^6.1.3",
+    "rimraf": "^3.0.2",
+    "typescript": "^5.4.5"
+  },
+  "gitHead": "afc0628ca4aeaba255eef9716652640fdc5b50c4"
+}