react-restyle-components 0.4.39 → 0.4.41

package/lib/src/core-components/src/components/TreeSelect/hooks.js

@@ -1 +1,252 @@
-"use strict";import{useState as x,useCallback as g,useEffect as L}from"react";export function getFieldValue(o,t,e={}){const n={label:e.label||"title",value:e.value||"value",children:e.children||"children"};return o[n[t]]}export function flattenTree(o,t,e){const n=[];for(const c of o){const r=getFieldValue(c,"value",t),a=getFieldValue(c,"children",t),f=e?[...e.path,r]:[r];n.push({...c,parent:e,path:f}),a&&Array.isArray(a)&&n.push(...flattenTree(a,t,{...c,path:f}))}return n}export function findNodeByValue(o,t,e){for(const n of o){const c=getFieldValue(n,"value",e),r=getFieldValue(n,"children",e);if(c===t)return n;if(r&&Array.isArray(r)){const a=findNodeByValue(r,t,e);if(a)return a}}}export function getDescendantValues(o,t){const e=[],n=getFieldValue(o,"children",t);if(n&&Array.isArray(n))for(const c of n){const r=getFieldValue(c,"value",t);e.push(r),e.push(...getDescendantValues(c,t))}return e}export function getAncestorValues(o,t,e){return flattenTree(o,e).find(r=>getFieldValue(r,"value",e)===t)?.path.slice(0,-1)||[]}export function filterTree(o,t,e,n="title",c){if(!t)return o;const a=e||((d,u)=>{const s=u[n];return typeof s=="string"?s.toLowerCase().includes(d.toLowerCase()):!1}),f=[];for(const d of o){const u=getFieldValue(d,"children",c),s=u?filterTree(u,t,e,n,c):[];(a(t,d)||s.length>0)&&f.push({...d,children:s.length>0?s:u})}return f}export function useExpandedState(o,t,e,n,c){const[r,a]=x(()=>{if(e){const s=new Set,i=h=>{for(const l of h){const C=getFieldValue(l,"value",c),p=getFieldValue(l,"children",c);p&&p.length>0&&(s.add(C),i(p))}};return i(o),s}return new Set(t||[])}),f=n?new Set(n):r,d=g(s=>{a(i=>{const h=new Set(i);return h.has(s)?h.delete(s):h.add(s),h})},[]),u=g(s=>{a(new Set(s))},[]);return{expandedKeys:f,toggleExpand:d,setExpanded:u}}export function useCheckedState(o,t,e=!1,n){const[c,r]=x(new Set(t||[])),[a,f]=x(new Set);L(()=>{t&&(r(new Set(t)),e||d(new Set(t)))},[t,e]);const d=g(s=>{if(e){f(new Set);return}const i=new Set,h=flattenTree(o,n);for(const l of h){const C=getFieldValue(l,"value",n),p=getFieldValue(l,"children",n);if(p&&p.length>0){const w=getDescendantValues(l,n),S=w.filter(K=>s.has(K));S.length>0&&S.length<w.length&&i.add(C)}}f(i)},[o,e,n]),u=g((s,i)=>{r(h=>{const l=new Set(h);return l.has(s)?(l.delete(s),e||getDescendantValues(i,n).forEach(w=>l.delete(w))):(l.add(s),e||getDescendantValues(i,n).forEach(w=>l.add(w))),e||v(l,s,o,n),d(l),l})},[e,o,n,d]);return{checkedKeys:c,halfCheckedKeys:a,toggleCheck:u,setCheckedKeys:r}}function v(o,t,e,n){const c=getAncestorValues(e,t,n);for(const r of c.reverse()){const a=findNodeByValue(e,r,n);a&&(getDescendantValues(a,n).every(u=>o.has(u))?o.add(r):o.delete(r))}}export function useAsyncLoading(){const[o,t]=x(new Set),[e,n]=x(new Set),c=g((d,u)=>{t(s=>{const i=new Set(s);return u?i.add(d):i.delete(d),i})},[]),r=g(d=>{n(u=>new Set(u).add(d)),t(u=>{const s=new Set(u);return s.delete(d),s})},[]),a=g(d=>o.has(d),[o]),f=g(d=>e.has(d),[e]);return{loadingKeys:o,setLoading:c,markLoaded:r,isLoading:a,isLoaded:f}}
+import { useState, useCallback, useEffect } from 'react';
+/**
+ * Get the actual field value based on field names mapping
+ */
+export function getFieldValue(node, field, fieldNames = {}) {
+    const mapping = {
+        label: fieldNames.label || 'title',
+        value: fieldNames.value || 'value',
+        children: fieldNames.children || 'children',
+    };
+    return node[mapping[field]];
+}
+/**
+ * Flatten tree data for easier searching
+ */
+export function flattenTree(nodes, fieldNames, parent) {
+    const result = [];
+    for (const node of nodes) {
+        const value = getFieldValue(node, 'value', fieldNames);
+        const children = getFieldValue(node, 'children', fieldNames);
+        const path = parent ? [...parent.path, value] : [value];
+        result.push({ ...node, parent, path });
+        if (children && Array.isArray(children)) {
+            result.push(...flattenTree(children, fieldNames, { ...node, path }));
+        }
+    }
+    return result;
+}
+/**
+ * Find a node by value
+ */
+export function findNodeByValue(nodes, value, fieldNames) {
+    for (const node of nodes) {
+        const nodeValue = getFieldValue(node, 'value', fieldNames);
+        const children = getFieldValue(node, 'children', fieldNames);
+        if (nodeValue === value)
+            return node;
+        if (children && Array.isArray(children)) {
+            const found = findNodeByValue(children, value, fieldNames);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get all descendant values
+ */
+export function getDescendantValues(node, fieldNames) {
+    const values = [];
+    const children = getFieldValue(node, 'children', fieldNames);
+    if (children && Array.isArray(children)) {
+        for (const child of children) {
+            const childValue = getFieldValue(child, 'value', fieldNames);
+            values.push(childValue);
+            values.push(...getDescendantValues(child, fieldNames));
+        }
+    }
+    return values;
+}
+/**
+ * Get all ancestor values
+ */
+export function getAncestorValues(nodes, targetValue, fieldNames) {
+    const flatNodes = flattenTree(nodes, fieldNames);
+    const target = flatNodes.find((n) => getFieldValue(n, 'value', fieldNames) === targetValue);
+    return target?.path.slice(0, -1) || [];
+}
+/**
+ * Filter tree nodes based on search
+ */
+export function filterTree(nodes, searchValue, filterFn, filterProp = 'title', fieldNames) {
+    if (!searchValue)
+        return nodes;
+    const defaultFilter = (value, node) => {
+        const nodeLabel = node[filterProp];
+        if (typeof nodeLabel === 'string') {
+            return nodeLabel.toLowerCase().includes(value.toLowerCase());
+        }
+        return false;
+    };
+    const filter = filterFn || defaultFilter;
+    const result = [];
+    for (const node of nodes) {
+        const children = getFieldValue(node, 'children', fieldNames);
+        const filteredChildren = children
+            ? filterTree(children, searchValue, filterFn, filterProp, fieldNames)
+            : [];
+        if (filter(searchValue, node) || filteredChildren.length > 0) {
+            result.push({
+                ...node,
+                children: filteredChildren.length > 0 ? filteredChildren : children,
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Hook for managing expanded state
+ */
+export function useExpandedState(treeData, defaultExpandedKeys, defaultExpandAll, controlledExpandedKeys, fieldNames) {
+    const [internalExpanded, setInternalExpanded] = useState(() => {
+        if (defaultExpandAll) {
+            const allKeys = new Set();
+            const collectKeys = (nodes) => {
+                for (const node of nodes) {
+                    const value = getFieldValue(node, 'value', fieldNames);
+                    const children = getFieldValue(node, 'children', fieldNames);
+                    if (children && children.length > 0) {
+                        allKeys.add(value);
+                        collectKeys(children);
+                    }
+                }
+            };
+            collectKeys(treeData);
+            return allKeys;
+        }
+        return new Set(defaultExpandedKeys || []);
+    });
+    const expandedKeys = controlledExpandedKeys
+        ? new Set(controlledExpandedKeys)
+        : internalExpanded;
+    const toggleExpand = useCallback((key) => {
+        setInternalExpanded((prev) => {
+            const next = new Set(prev);
+            if (next.has(key)) {
+                next.delete(key);
+            }
+            else {
+                next.add(key);
+            }
+            return next;
+        });
+    }, []);
+    const setExpanded = useCallback((keys) => {
+        setInternalExpanded(new Set(keys));
+    }, []);
+    return { expandedKeys, toggleExpand, setExpanded };
+}
+/**
+ * Hook for managing checked state (checkable mode)
+ */
+export function useCheckedState(treeData, value, checkStrictly = false, fieldNames) {
+    const [checkedKeys, setCheckedKeys] = useState(new Set(value || []));
+    const [halfCheckedKeys, setHalfCheckedKeys] = useState(new Set());
+    // Update when controlled value changes
+    useEffect(() => {
+        if (value) {
+            setCheckedKeys(new Set(value));
+            if (!checkStrictly) {
+                updateHalfChecked(new Set(value));
+            }
+        }
+    }, [value, checkStrictly]);
+    const updateHalfChecked = useCallback((checked) => {
+        if (checkStrictly) {
+            setHalfCheckedKeys(new Set());
+            return;
+        }
+        const half = new Set();
+        const flatNodes = flattenTree(treeData, fieldNames);
+        // Check each parent node
+        for (const node of flatNodes) {
+            const nodeValue = getFieldValue(node, 'value', fieldNames);
+            const children = getFieldValue(node, 'children', fieldNames);
+            if (children && children.length > 0) {
+                const descendantValues = getDescendantValues(node, fieldNames);
+                const checkedDescendants = descendantValues.filter((v) => checked.has(v));
+                if (checkedDescendants.length > 0 &&
+                    checkedDescendants.length < descendantValues.length) {
+                    half.add(nodeValue);
+                }
+            }
+        }
+        setHalfCheckedKeys(half);
+    }, [treeData, checkStrictly, fieldNames]);
+    const toggleCheck = useCallback((nodeValue, node) => {
+        setCheckedKeys((prev) => {
+            const next = new Set(prev);
+            const isChecked = next.has(nodeValue);
+            if (isChecked) {
+                next.delete(nodeValue);
+                if (!checkStrictly) {
+                    // Uncheck all descendants
+                    const descendants = getDescendantValues(node, fieldNames);
+                    descendants.forEach((v) => next.delete(v));
+                }
+            }
+            else {
+                next.add(nodeValue);
+                if (!checkStrictly) {
+                    // Check all descendants
+                    const descendants = getDescendantValues(node, fieldNames);
+                    descendants.forEach((v) => next.add(v));
+                }
+            }
+            // Update parent states if not strict
+            if (!checkStrictly) {
+                updateParentStates(next, nodeValue, treeData, fieldNames);
+            }
+            updateHalfChecked(next);
+            return next;
+        });
+    }, [checkStrictly, treeData, fieldNames, updateHalfChecked]);
+    return { checkedKeys, halfCheckedKeys, toggleCheck, setCheckedKeys };
+}
+function updateParentStates(checked, changedValue, treeData, fieldNames) {
+    const ancestors = getAncestorValues(treeData, changedValue, fieldNames);
+    for (const ancestorValue of ancestors.reverse()) {
+        const ancestorNode = findNodeByValue(treeData, ancestorValue, fieldNames);
+        if (ancestorNode) {
+            const descendants = getDescendantValues(ancestorNode, fieldNames);
+            const allChecked = descendants.every((v) => checked.has(v));
+            if (allChecked) {
+                checked.add(ancestorValue);
+            }
+            else {
+                checked.delete(ancestorValue);
+            }
+        }
+    }
+}
+/**
+ * Hook for managing async loading
+ */
+export function useAsyncLoading() {
+    const [loadingKeys, setLoadingKeys] = useState(new Set());
+    const [loadedKeys, setLoadedKeys] = useState(new Set());
+    const setLoading = useCallback((key, isLoading) => {
+        setLoadingKeys((prev) => {
+            const next = new Set(prev);
+            if (isLoading) {
+                next.add(key);
+            }
+            else {
+                next.delete(key);
+            }
+            return next;
+        });
+    }, []);
+    const markLoaded = useCallback((key) => {
+        setLoadedKeys((prev) => new Set(prev).add(key));
+        setLoadingKeys((prev) => {
+            const next = new Set(prev);
+            next.delete(key);
+            return next;
+        });
+    }, []);
+    const isLoading = useCallback((key) => loadingKeys.has(key), [loadingKeys]);
+    const isLoaded = useCallback((key) => loadedKeys.has(key), [loadedKeys]);
+    return { loadingKeys, setLoading, markLoaded, isLoading, isLoaded };
+}

package/lib/src/core-components/src/components/TreeSelect/index.js

@@ -1 +1,3 @@
-"use strict";export{TreeSelect,default}from"./TreeSelect";export*from"./types";export{flattenTree,findNodeByValue,getDescendantValues,getAncestorValues,filterTree,getFieldValue}from"./hooks";
+export { TreeSelect, default } from './TreeSelect';
+export * from './types';
+export { flattenTree, findNodeByValue, getDescendantValues, getAncestorValues, filterTree, getFieldValue, } from './hooks';

package/lib/src/core-components/src/components/TreeSelect/types.js

@@ -1 +1 @@
-"use strict";export{};
+export {};

package/lib/src/core-components/src/components/ag-grid/AgGrid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AG Grid Component
+ * A comprehensive, AG Grid-like data table with all enterprise features
+ * Reference: https://www.ag-grid.com/react-data-grid/getting-started/
+ */
+import React from 'react';
+import type { AgGridProps, AgGridRef } from './types';
+export declare const AgGrid: <T extends Record<string, any>>(props: AgGridProps<T> & {
+    ref?: React.ForwardedRef<AgGridRef<T>> | undefined;
+}) => React.ReactElement;
+export default AgGrid;