awing-library 2.1.2-dev.99 → 2.1.2-preview.1

package/dist/Features/SYSTEM/Schema/components/SchemaInformation.js

@@ -0,0 +1,105 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Typography } from "@mui/material";
+import { DataForm, FIELD_TYPE, textValidation } from "../../../../AWING/index.js";
+import { patternFieldText } from "../../../constants.js";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { forwardRef, useImperativeHandle, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { confirmExitState, currentSchemaState, fullFieldsState, objectTypeCodesState, schemaState } from "../Atoms.js";
+import { useGetSchemaContext } from "../context.js";
+import { TreeSchema } from "./treeSchema.js";
+const SchemaInformation_SchemaInformation = /*#__PURE__*/ forwardRef((_props, ref)=>{
+    const { t } = useTranslation();
+    const { services } = useGetSchemaContext();
+    const treeSchemaRef = useRef(null);
+    const [_fullFields, setFullFields] = useAtom(fullFieldsState);
+    const objectTypeCodes = useAtomValue(objectTypeCodesState);
+    const schema = useAtomValue(schemaState);
+    const [currentSchema, setCurrentSchema] = useAtom(currentSchemaState);
+    const setConfirmExit = useSetAtom(confirmExitState);
+    const isCreate = !schema?.id;
+    const [isChangeName, setIsChangeName] = useState(false);
+    const handleChangeObjectTypeCode = (e)=>{
+        const value = e.target?.value;
+        setCurrentSchema((prev)=>({
+                ...prev,
+                objectTypeCode: value
+            }));
+        isCreate && setConfirmExit(true);
+        services?.getTypeDefinitions({
+            objectTypeCode: value
+        }).then((data)=>{
+            setFullFields(data.items);
+        }).catch((error)=>{
+            console.error('Error fetching type definitions:', error);
+        });
+    };
+    const handleChangeSchemaName = (e)=>{
+        setCurrentSchema((prev)=>({
+                ...prev,
+                name: e.target?.value
+            }));
+        setConfirmExit(true);
+        isChangeName || setIsChangeName(true);
+    };
+    const { valid, message } = textValidation(currentSchema?.name || '', 200, true, patternFieldText);
+    useImperativeHandle(ref, ()=>({
+            prepareDataForBackend: ()=>treeSchemaRef.current?.prepareDataForBackend() || [],
+            hasValidationErrors: ()=>treeSchemaRef.current?.hasValidationErrors() || false
+        }), []);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(DataForm, {
+                autoValidateFieldText: true,
+                fields: [
+                    {
+                        fieldName: 'objectTypeCode',
+                        type: FIELD_TYPE.SELECT,
+                        label: t('Schema.ObjectLabel'),
+                        required: true,
+                        options: (objectTypeCodes ?? []).map((item)=>({
+                                value: item.objectTypeCode ?? '',
+                                text: item.typeDefinitionName
+                            })),
+                        inputProps: {
+                            disabled: !isCreate,
+                            onChange: handleChangeObjectTypeCode,
+                            'data-testid': 'objectTypeCode'
+                        }
+                    },
+                    {
+                        fieldName: 'name',
+                        type: FIELD_TYPE.TEXT,
+                        label: t('Schema.Name'),
+                        required: true,
+                        value: currentSchema?.name,
+                        length: 200,
+                        inputProps: {
+                            onChange: handleChangeSchemaName,
+                            'data-testid': 'SchemaName',
+                            helperText: isChangeName && !valid ? message : ''
+                        }
+                    }
+                ],
+                oldValue: {
+                    objectTypeCode: schema?.objectTypeCode,
+                    name: schema?.name
+                },
+                padding: 'none'
+            }, schema?.id || 'new'),
+            /*#__PURE__*/ jsx(Typography, {
+                sx: {
+                    fontWeight: 'bold',
+                    pt: 2,
+                    pb: 2
+                },
+                children: `${t('Schema.FieldLabel')} *`
+            }),
+            /*#__PURE__*/ jsx(TreeSchema, {
+                ref: treeSchemaRef
+            })
+        ]
+    });
+});
+const SchemaInformation = SchemaInformation_SchemaInformation;
+export { SchemaInformation as default };

package/dist/Features/SYSTEM/Schema/components/TabConfigtion.d.ts

@@ -0,0 +1,7 @@
+export interface TabConfigtionRef {
+    prepareDataForBackend: () => any[];
+    hasValidationErrors: () => boolean;
+}
+declare const TabConfigtion: import("react").ForwardRefExoticComponent<import("react").RefAttributes<TabConfigtionRef>>;
+export default TabConfigtion;
+//# sourceMappingURL=TabConfigtion.d.ts.map

package/dist/Features/SYSTEM/Schema/components/TabConfigtion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabConfigtion.d.ts","sourceRoot":"","sources":["../../../../../src/Features/SYSTEM/Schema/components/TabConfigtion.tsx"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAC7B,qBAAqB,EAAE,MAAM,GAAG,EAAE,CAAC;IACnC,mBAAmB,EAAE,MAAM,OAAO,CAAC;CACtC;AAED,QAAA,MAAM,aAAa,4FAiDjB,CAAC;AAEH,eAAe,aAAa,CAAC"}

package/dist/Features/SYSTEM/Schema/components/TabConfigtion.js

@@ -0,0 +1,62 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Box, Grid, Paper, Tab, Tabs } from "@mui/material";
+import { forwardRef, useImperativeHandle, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { TabContext, TabPanel } from "@mui/lab";
+import SchemaInformation from "./SchemaInformation.js";
+const TabConfigtion_TabConfigtion = /*#__PURE__*/ forwardRef((_props, ref)=>{
+    const { t } = useTranslation();
+    const [tabValue, setTabValue] = useState('1');
+    const schemaInformationRef = useRef(null);
+    useImperativeHandle(ref, ()=>({
+            prepareDataForBackend: ()=>schemaInformationRef.current?.prepareDataForBackend() || [],
+            hasValidationErrors: ()=>schemaInformationRef.current?.hasValidationErrors() || false
+        }), []);
+    return /*#__PURE__*/ jsx(Grid, {
+        container: true,
+        sx: {
+            flexGrow: 1,
+            padding: (theme)=>theme.spacing(3)
+        },
+        children: /*#__PURE__*/ jsx(Grid, {
+            size: {
+                xs: 12
+            },
+            component: Paper,
+            children: /*#__PURE__*/ jsxs(TabContext, {
+                value: tabValue,
+                children: [
+                    /*#__PURE__*/ jsx(Box, {
+                        sx: {
+                            borderBottom: 1,
+                            borderColor: 'divider'
+                        },
+                        children: /*#__PURE__*/ jsx(Tabs, {
+                            value: tabValue,
+                            onChange: (_e, newValue)=>setTabValue(newValue),
+                            variant: "scrollable",
+                            scrollButtons: true,
+                            allowScrollButtonsMobile: true,
+                            "aria-label": "scrollable tabs",
+                            children: /*#__PURE__*/ jsx(Tab, {
+                                label: t('Schema.Tab.Information'),
+                                value: "1",
+                                style: {
+                                    fontWeight: 'bold'
+                                }
+                            })
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(TabPanel, {
+                        value: "1",
+                        children: /*#__PURE__*/ jsx(SchemaInformation, {
+                            ref: schemaInformationRef
+                        })
+                    })
+                ]
+            })
+        })
+    });
+});
+const TabConfigtion = TabConfigtion_TabConfigtion;
+export { TabConfigtion as default };

package/dist/Features/SYSTEM/Schema/components/treeSchema.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface TreeSchemaRef {
+    prepareDataForBackend: () => any[];
+    hasValidationErrors: () => boolean;
+}
+export declare const TreeSchema: React.ForwardRefExoticComponent<React.RefAttributes<TreeSchemaRef>>;
+//# sourceMappingURL=treeSchema.d.ts.map

package/dist/Features/SYSTEM/Schema/components/treeSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeSchema.d.ts","sourceRoot":"","sources":["../../../../../src/Features/SYSTEM/Schema/components/treeSchema.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAoC/B,MAAM,WAAW,aAAa;IAC1B,qBAAqB,EAAE,MAAM,GAAG,EAAE,CAAC;IACnC,mBAAmB,EAAE,MAAM,OAAO,CAAC;CACtC;AAwSD,eAAO,MAAM,UAAU,qEA6RrB,CAAC"}

package/dist/Features/SYSTEM/Schema/components/treeSchema.js

@@ -0,0 +1,465 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Box, Checkbox, TextField, Typography } from "@mui/material";
+import Stack from "@mui/material/Stack";
+import { useTreeItemModel } from "@mui/x-tree-view/hooks";
+import { RichTreeView } from "@mui/x-tree-view/RichTreeView";
+import { TreeItem } from "@mui/x-tree-view/TreeItem";
+import { useTreeItem } from "@mui/x-tree-view/useTreeItem";
+import { forwardRef, memo, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { useAtomValue, useSetAtom } from "jotai";
+import { useTranslation } from "react-i18next";
+import { confirmExitState, currentSchemaState, fullFieldsState, validationErrorsState } from "../Atoms.js";
+import { convertDataSchemaToTreeView, validateJsonString } from "../utils.js";
+const rootId = 'root';
+const FilterInput = /*#__PURE__*/ memo(({ itemId, initialValue, disabled, onUpdate, item, selectedItems })=>{
+    const [localValue, setLocalValue] = useState(initialValue);
+    const prevInitialValueRef = useRef(initialValue);
+    useEffect(()=>{
+        if (prevInitialValueRef.current !== initialValue) {
+            setLocalValue(initialValue);
+            prevInitialValueRef.current = initialValue;
+        }
+    }, [
+        initialValue
+    ]);
+    useEffect(()=>{
+        if (disabled && '' !== localValue) {
+            setLocalValue('');
+            onUpdate(itemId, '');
+        }
+    }, [
+        disabled,
+        itemId,
+        onUpdate
+    ]);
+    const fieldOfSchemaValid = validateJsonString(localValue ?? '', item, selectedItems);
+    const handleChange = useCallback((event)=>{
+        event.stopPropagation();
+        setLocalValue(event.target.value);
+    }, []);
+    const handleBlur = useCallback(()=>{
+        onUpdate(itemId, localValue);
+    }, [
+        itemId,
+        localValue,
+        onUpdate
+    ]);
+    return /*#__PURE__*/ jsx(TextField, {
+        disabled: disabled,
+        value: localValue,
+        onChange: handleChange,
+        onBlur: handleBlur,
+        onClick: (e)=>e.stopPropagation(),
+        sx: {
+            width: '206px'
+        },
+        variant: "standard",
+        error: !!localValue && !fieldOfSchemaValid.isValid,
+        helperText: localValue && !fieldOfSchemaValid.isValid ? fieldOfSchemaValid.error : ''
+    });
+});
+FilterInput.displayName = 'FilterInput';
+function DirectPrimaryKey(fieldPath, isPrimaryKey) {
+    if (!fieldPath || !isPrimaryKey) return false;
+    const paths = fieldPath.split('.').filter(Boolean);
+    return 1 === paths.length;
+}
+function getInitialSelectedItems(items) {
+    const defaultIds = [];
+    const selectedIds = [];
+    const traverse = (nodes)=>{
+        nodes.forEach((node)=>{
+            const id = String(node.id);
+            let shouldSelect = false;
+            if (DirectPrimaryKey(node.fieldPath, node.isPrimaryKey)) {
+                defaultIds.push(id);
+                shouldSelect = true;
+            } else if (void 0 !== node.isReadOnly && null !== node.isReadOnly && !((node.children?.length ?? 0) > 0)) shouldSelect = true;
+            if (node.children) {
+                if (node.children.length > 0 && node.children.every((child)=>void 0 !== child.isReadOnly && null !== child.isReadOnly)) shouldSelect = true;
+                traverse(node.children);
+            }
+            if (shouldSelect) selectedIds.push(id);
+        });
+    };
+    traverse(items);
+    return {
+        defaultIds,
+        selectedIds
+    };
+}
+const treeSchema_CustomTreeItem = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function(props, ref) {
+    const { itemStateMap, onUpdateItemState, selectedItems, ...treeItemProps } = props;
+    const { t } = useTranslation();
+    const { status } = useTreeItem({
+        itemId: props.itemId,
+        id: props.id,
+        label: props.label,
+        disabled: props.disabled,
+        rootRef: ref
+    });
+    const item = useTreeItemModel(props.itemId);
+    const itemState = itemStateMap.get(props.itemId);
+    const filterValue = itemState?.filter || '';
+    const isChecked = itemState?.isReadOnly || false;
+    const hasChildren = void 0 !== props.children && null !== props.children && 'object' == typeof props.children && props.children.length > 0;
+    const handleFilterUpdate = useCallback((itemId, value)=>{
+        onUpdateItemState(itemId, 'filter', value);
+    }, [
+        onUpdateItemState
+    ]);
+    const handleCheckboxChange = useCallback((event)=>{
+        event.stopPropagation();
+        onUpdateItemState(props.itemId, 'isReadOnly', event.target.checked);
+    }, [
+        onUpdateItemState,
+        props.itemId
+    ]);
+    const hasSelectedChild = useMemo(()=>{
+        if (!item || !item.children) return false;
+        const checkChildren = (children)=>children.some((child)=>{
+                const childId = String(child.id);
+                if (selectedItems.includes(childId)) return true;
+                if (child.children) return checkChildren(child.children);
+                return false;
+            });
+        return checkChildren(item.children);
+    }, [
+        item,
+        selectedItems
+    ]);
+    const hasChildSelected = status.selected || hasSelectedChild;
+    return /*#__PURE__*/ jsx(TreeItem, {
+        ...treeItemProps,
+        ref: ref,
+        slots: {
+            checkbox: (checkboxProps)=>{
+                const { visible, ...checkbox } = checkboxProps;
+                return /*#__PURE__*/ jsx(Checkbox, {
+                    ...checkbox,
+                    checked: checkbox.checked,
+                    sx: {
+                        cursor: 'pointer'
+                    },
+                    disabled: DirectPrimaryKey(item?.fieldPath, item?.isPrimaryKey)
+                });
+            },
+            label: ({ children, ownerState, editable, ...other })=>/*#__PURE__*/ jsxs(Box, {
+                    ...other,
+                    sx: {
+                        display: 'flex',
+                        alignItems: 'center',
+                        gap: 1,
+                        width: '100%',
+                        backgroundColor: hasChildren ? 'rgba(25, 118, 210, 0.08)' : 'transparent',
+                        padding: '4px 8px',
+                        borderRadius: 1
+                    },
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            children: children
+                        }),
+                        /*#__PURE__*/ jsx(Box, {
+                            sx: {
+                                display: 'flex',
+                                alignItems: 'center',
+                                gap: 1,
+                                marginLeft: 'auto'
+                            },
+                            children: /*#__PURE__*/ jsxs(Box, {
+                                sx: {
+                                    display: 'flex',
+                                    justifyItems: 'end'
+                                },
+                                children: [
+                                    hasChildren && (props.itemId === rootId ? /*#__PURE__*/ jsx(Typography, {
+                                        variant: "body1",
+                                        fontWeight: 'bold',
+                                        sx: {
+                                            width: '206px',
+                                            textAlign: 'start'
+                                        },
+                                        children: "Filter"
+                                    }) : item?.targetType && item.targetType.includes('[') && item.targetType.includes(']') ? /*#__PURE__*/ jsx(FilterInput, {
+                                        itemId: props.itemId,
+                                        initialValue: filterValue,
+                                        disabled: !hasChildSelected,
+                                        onUpdate: handleFilterUpdate,
+                                        item: item,
+                                        selectedItems: selectedItems
+                                    }) : null),
+                                    props.itemId === rootId ? /*#__PURE__*/ jsx(Typography, {
+                                        variant: "body1",
+                                        fontWeight: 'bold',
+                                        sx: {
+                                            width: '100px',
+                                            textAlign: 'center'
+                                        },
+                                        children: t('Schema.ReadOnly')
+                                    }) : /*#__PURE__*/ jsx(Checkbox, {
+                                        disabled: !status.selected,
+                                        checked: isChecked,
+                                        onChange: handleCheckboxChange,
+                                        onClick: (e)=>e.stopPropagation(),
+                                        size: "small",
+                                        sx: {
+                                            width: '100px',
+                                            textAlign: 'center'
+                                        }
+                                    })
+                                ]
+                            })
+                        })
+                    ]
+                })
+        }
+    });
+}), (prevProps, nextProps)=>{
+    const prevState = prevProps.itemStateMap.get(prevProps.itemId);
+    const nextState = nextProps.itemStateMap.get(nextProps.itemId);
+    const stateUnchanged = prevState?.filter === nextState?.filter && prevState?.isReadOnly === nextState?.isReadOnly;
+    const callbackUnchanged = prevProps.onUpdateItemState === nextProps.onUpdateItemState;
+    return prevProps.itemId === nextProps.itemId && stateUnchanged && callbackUnchanged;
+});
+const TreeSchema = /*#__PURE__*/ forwardRef((_props, ref)=>{
+    const currentSchema = useAtomValue(currentSchemaState);
+    const fullFields = useAtomValue(fullFieldsState);
+    const setConfirmExit = useSetAtom(confirmExitState);
+    const setValidationErrors = useSetAtom(validationErrorsState);
+    const DEMO_TREE_DATA = useMemo(()=>convertDataSchemaToTreeView(fullFields, currentSchema.schemaObjectDefinitions, currentSchema.objectTypeCode), [
+        fullFields,
+        currentSchema.schemaObjectDefinitions,
+        currentSchema.objectTypeCode
+    ]);
+    const [selectedItems, setSelectedItems] = useState([]);
+    const [defaultIds, setDefaultIds] = useState([]);
+    useEffect(()=>{
+        const { defaultIds, selectedIds } = getInitialSelectedItems(DEMO_TREE_DATA);
+        setSelectedItems(selectedIds);
+        setDefaultIds(defaultIds);
+    }, [
+        DEMO_TREE_DATA
+    ]);
+    const [itemStateMap, setItemStateMap] = useState(()=>{
+        const initialMap = new Map();
+        const initializeMap = (items)=>{
+            items.forEach((item)=>{
+                initialMap.set(item.id, {
+                    filter: item.filter || '',
+                    isReadOnly: item.isReadOnly || false
+                });
+                if (item.children) initializeMap(item.children);
+            });
+        };
+        initializeMap(DEMO_TREE_DATA);
+        return initialMap;
+    });
+    useEffect(()=>{
+        const newMap = new Map();
+        const initializeMap = (items)=>{
+            items.forEach((item)=>{
+                newMap.set(item.id, {
+                    filter: item.filter || '',
+                    isReadOnly: item.isReadOnly || false
+                });
+                if (item.children) initializeMap(item.children);
+            });
+        };
+        initializeMap(DEMO_TREE_DATA);
+        setItemStateMap(newMap);
+    }, [
+        DEMO_TREE_DATA
+    ]);
+    useEffect(()=>{
+        const checkErrors = ()=>{
+            const originalItemsMap = new Map();
+            const buildOriginalMap = (items)=>{
+                items.forEach((item)=>{
+                    originalItemsMap.set(String(item.id), {
+                        id: item.id,
+                        label: item.label,
+                        fieldPath: item.fieldPath,
+                        filter: item.filter,
+                        isReadOnly: item.isReadOnly,
+                        isPrimaryKey: item.isPrimaryKey,
+                        typeDefinitionId: item.typeDefinitionId,
+                        targetType: item.targetType,
+                        children: item.children
+                    });
+                    if ('root' === String(item.id) && item.children) buildOriginalMap(item.children);
+                });
+            };
+            buildOriginalMap(DEMO_TREE_DATA);
+            for (const [itemId, currentState] of itemStateMap.entries())if (currentState.filter) {
+                const originalItem = originalItemsMap.get(itemId);
+                if (originalItem) {
+                    const validation = validateJsonString(currentState.filter, originalItem, selectedItems);
+                    if (!validation.isValid) return true;
+                }
+            }
+            return false;
+        };
+        setValidationErrors(checkErrors());
+    }, [
+        itemStateMap,
+        selectedItems,
+        DEMO_TREE_DATA,
+        setValidationErrors
+    ]);
+    const handleUpdateItemState = useCallback((itemId, field, value)=>{
+        setItemStateMap((prevMap)=>{
+            const newMap = new Map(prevMap);
+            const currentState = newMap.get(itemId);
+            if (currentState) newMap.set(itemId, {
+                ...currentState,
+                [field]: value
+            });
+            return newMap;
+        });
+        setConfirmExit(true);
+    }, [
+        setConfirmExit
+    ]);
+    const getChangedItems = useCallback(()=>{
+        const changedItems = [];
+        const originalItemsMap = new Map();
+        const buildOriginalMap = (items)=>{
+            items.forEach((item)=>{
+                originalItemsMap.set(String(item.id), {
+                    id: item.id,
+                    label: item.label,
+                    fieldPath: item.fieldPath,
+                    filter: item.filter,
+                    isReadOnly: item.isReadOnly,
+                    isPrimaryKey: item.isPrimaryKey,
+                    typeDefinitionId: item.typeDefinitionId
+                });
+                if (item.children) buildOriginalMap(item.children);
+            });
+        };
+        buildOriginalMap(DEMO_TREE_DATA);
+        itemStateMap.forEach((currentState, itemId)=>{
+            const originalItem = originalItemsMap.get(itemId);
+            if (originalItem) {
+                const isSelected = selectedItems.includes(itemId);
+                changedItems.push({
+                    id: itemId,
+                    fieldPath: originalItem.fieldPath,
+                    typeDefinitionId: originalItem.typeDefinitionId,
+                    filter: currentState.filter,
+                    isReadOnly: currentState.isReadOnly,
+                    isSelected: isSelected
+                });
+            }
+        });
+        return changedItems;
+    }, [
+        itemStateMap,
+        selectedItems
+    ]);
+    const prepareDataForBackend = useCallback(()=>{
+        const changedItems = getChangedItems();
+        return changedItems.filter((item)=>(item.isSelected || item.filter || item.isReadOnly) && 'root' !== item.id).map((item)=>{
+            const id = item.id.includes('_') ? item.id.split('_')[0] : item.id;
+            return {
+                typeDefinitionId: item.typeDefinitionId,
+                fieldPath: item.fieldPath,
+                filter: item.filter || null,
+                isReadOnly: item.isReadOnly,
+                ...!isNaN(Number(id)) ? {
+                    id: Number(id)
+                } : {}
+            };
+        });
+    }, [
+        getChangedItems
+    ]);
+    const hasValidationErrors = useCallback(()=>{
+        const originalItemsMap = new Map();
+        const buildOriginalMap = (items)=>{
+            items.forEach((item)=>{
+                originalItemsMap.set(String(item.id), {
+                    id: item.id,
+                    label: item.label,
+                    fieldPath: item.fieldPath,
+                    filter: item.filter,
+                    isReadOnly: item.isReadOnly,
+                    isPrimaryKey: item.isPrimaryKey,
+                    typeDefinitionId: item.typeDefinitionId,
+                    targetType: item.targetType,
+                    children: item.children
+                });
+                if ('root' === String(item.id) && item.children) buildOriginalMap(item.children);
+            });
+        };
+        buildOriginalMap(DEMO_TREE_DATA);
+        for (const [itemId, currentState] of itemStateMap.entries())if (currentState.filter) {
+            const originalItem = DEMO_TREE_DATA.find((item)=>String(item.id) === itemId);
+            if (originalItem) {
+                const validation = validateJsonString(currentState.filter, originalItem, selectedItems);
+                if (!validation.isValid) return true;
+            }
+        }
+        return false;
+    }, [
+        itemStateMap,
+        selectedItems,
+        DEMO_TREE_DATA
+    ]);
+    useImperativeHandle(ref, ()=>({
+            prepareDataForBackend,
+            hasValidationErrors
+        }), [
+        prepareDataForBackend,
+        hasValidationErrors
+    ]);
+    const handleSelectionChange = useCallback((_event, nodeIds)=>{
+        const newNodeIds = [
+            ...new Set([
+                ...defaultIds,
+                ...nodeIds
+            ])
+        ];
+        setSelectedItems(newNodeIds);
+        setConfirmExit(true);
+    }, [
+        setConfirmExit,
+        defaultIds
+    ]);
+    const TreeItemComponent = useMemo(()=>(props)=>/*#__PURE__*/ jsx(treeSchema_CustomTreeItem, {
+                ...props,
+                itemStateMap: itemStateMap,
+                onUpdateItemState: handleUpdateItemState,
+                selectedItems: selectedItems
+            }), [
+        itemStateMap,
+        handleUpdateItemState,
+        selectedItems
+    ]);
+    return /*#__PURE__*/ jsx(Stack, {
+        sx: {
+            minHeight: 200,
+            minWidth: 350
+        },
+        spacing: 2,
+        children: /*#__PURE__*/ jsx(RichTreeView, {
+            defaultExpandedItems: [
+                'root'
+            ],
+            selectedItems: selectedItems,
+            items: DEMO_TREE_DATA,
+            slots: {
+                item: TreeItemComponent
+            },
+            multiSelect: true,
+            checkboxSelection: true,
+            selectionPropagation: {
+                descendants: true,
+                parents: true
+            },
+            onSelectedItemsChange: handleSelectionChange,
+            onKeyDownCapture: (e)=>e.stopPropagation()
+        })
+    });
+});
+export { TreeSchema };

package/dist/Features/SYSTEM/Schema/context.d.ts

@@ -0,0 +1,16 @@
+import { MutableRefObject } from 'react';
+import type { SchemaServices } from './Services';
+import type { CurrentWorkspace } from '../types';
+import { PageManagementRef } from '../../../index';
+export type SchemaContextType = {
+    /** currentWorkspace pass from SchemaComponent props */
+    currentWorkspace?: CurrentWorkspace;
+    /** All Service */
+    services?: SchemaServices;
+    tableRef?: MutableRefObject<PageManagementRef | undefined>;
+};
+/** Context for all Schema feature  */
+export declare const SchemaContext: import("react").Context<SchemaContextType>;
+/** Get Context of SchemaContext */
+export declare const useGetSchemaContext: () => SchemaContextType;
+//# sourceMappingURL=context.d.ts.map

package/dist/Features/SYSTEM/Schema/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/Features/SYSTEM/Schema/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAE1C,MAAM,MAAM,iBAAiB,GAAG;IAC5B,uDAAuD;IACvD,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAEpC,kBAAkB;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B,QAAQ,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;CAC9D,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,aAAa,4CAAuC,CAAC;AAElE,mCAAmC;AACnC,eAAO,MAAM,mBAAmB,yBAI/B,CAAC"}