LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows
Python ai-agentsdata-engineeringdocument-aigenerative-aiidpjson-extractionllmmcp-serverocrpdf-extractionprompt-engineeringstructured-output
import { ChevronDown } from "lucide-react";
import PropTypes from "prop-types";
import { useEffect, useRef, useState } from "react";
import { Tree } from "@/components/ui/shims/antd-structure";
import { Text } from "@/components/ui/shims/antd-typography";
import { Document, Folder } from "../../../assets";
import { formatBytes } from "../../../helpers/GetStaticData";
import { useExceptionHandler } from "../../../hooks/useExceptionHandler";
import { inputService } from "../../input-output/input-output/input-service.js";
import { SpinnerLoader } from "../../widgets/spinner-loader/SpinnerLoader.jsx";
import "./FileSystem.css";
const { DirectoryTree } = Tree;
function FileExplorer({
selectedConnector = "",
data = [],
loadingData,
error,
setError,
onFolderSelect,
selectedFolderPath,
}) {
const inpService = inputService();
const handleException = useExceptionHandler();
const [tree, setTree] = useState([]);
const [expandedKeys, setExpandedKeys] = useState([]);
const [selectedKeys, setSelectedKeys] = useState([]);
const [autoExpandParent, setAutoExpandParent] = useState(true);
const uploadPathRef = useRef("");
useEffect(() => {
const treeData = structuredClone(data);
updateTree(treeData);
}, [data, loadingData, error]);
useEffect(() => {
// Clear selected items/keys when the data source is changed.
setExpandedKeys([]);
setSelectedKeys([]);
if (setError) {
setError("");
}
}, [selectedConnector]);
useEffect(() => {
// Clear tree selection when selectedFolderPath is cleared
if (!selectedFolderPath) {
setSelectedKeys([]);
}
}, [selectedFolderPath]);
function onLoadData({ key, children }) {
return new Promise((resolve) => {
if (children) {
resolve();
return;
}
getAndUpdateFiles(key)
.then(() => {
resolve();
})
.catch(() => {
// Intentionally empty: errors handled upstream
});
});
}
function getAndUpdateFiles(path) {
if (setError) {
setError("");
}
return inpService
.getFileList(selectedConnector, path)
.then((res) => {
let newTree = tree;
if (path) {
const targetNode = getTargetNode(path, newTree);
targetNode["children"] = res.data;
} else {
newTree = res.data;
}
updateTree(newTree);
})
.catch((err) => {
const errorDetails = handleException(
err,
`Error loading files from "${path || "root"}"`,
);
if (setError) {
setError(errorDetails.content);
}
throw err;
});
}
function onSelect(selectedKeys, event) {
setSelectedKeys(selectedKeys);
if (event.node.isLeaf) {
uploadPathRef.current = "";
// Call the folder selection callback for files (disabled state)
if (onFolderSelect) {
onFolderSelect(event.node.key, "file");
}
} else {
uploadPathRef.current = event.node.key;
// Call the folder selection callback for folders (enabled state)
if (onFolderSelect) {
onFolderSelect(event.node.key, "folder");
}
}
}
function onExpand(newExpandedKeys) {
setExpandedKeys(newExpandedKeys);
setAutoExpandParent(false);
}
function updateTree(treeData) {
transformTree(treeData);
setTree([...treeData]);
setSelectedKeys([]);
}
return (
<div className="storageExplorer">
{tree.length !== 0 && (
<>
<div className="fileText fileHeading">
<Text type="secondary" ellipsis strong>
Name
</Text>
<Text type="secondary" ellipsis strong>
Size
</Text>
<Text type="secondary" ellipsis strong>
Modified at
</Text>
</div>
<DirectoryTree
rootClassName="explorerTree"
showLine
treeData={tree}
switcherIcon={<ChevronDown />}
expandedKeys={expandedKeys}
selectedKeys={selectedKeys}
autoExpandParent={autoExpandParent}
onExpand={onExpand}
onSelect={onSelect}
loadData={onLoadData}
expandAction={false}
/>
</>
)}
{loadingData && <SpinnerLoader />}
{tree?.length === 0 && !error && (
<div className="center">
<Text>No files</Text>
</div>
)}
{error && (
<div className="center">
<Text>{error}</Text>
</div>
)}
</div>
);
}
FileExplorer.propTypes = {
data: PropTypes.array,
};
function getTargetNode(key, treeData) {
let targetNode;
for (const node of treeData) {
if (node.key === key) {
targetNode = node;
break;
} else if (node.children) {
const findTargetNode = getTargetNode(key, node.children);
if (findTargetNode) {
targetNode = findTargetNode;
break;
}
}
}
return targetNode;
}
function transformTree(tree) {
let key = "";
let title = "";
let isFile = "";
let modifiedDate = "";
let size = "";
tree.forEach((node) => {
key = node.name;
title = key.split("/").at(-1);
isFile = node.type === "file";
modifiedDate = node.modified_at?.split(" ")[0] || "";
// Blank when size is 0/unknown (e.g. Google-native docs) instead of "0 B".
size = isFile && node.size ? formatBytes(node.size) : "";
node["key"] = key;
node["icon"] = isFile ? <Document /> : <Folder />;
node["title"] = (
<div className="fileText">
<Text ellipsis>{title}</Text>
<Text>{size}</Text>
<Text>{modifiedDate}</Text>
</div>
);
node["isLeaf"] = isFile;
if (node.children) {
transformTree(node.children);
}
});
}
FileExplorer.propTypes = {
selectedConnector: PropTypes.string,
data: PropTypes.array,
loadingData: PropTypes.bool,
error: PropTypes.string,
setError: PropTypes.func,
onFolderSelect: PropTypes.func,
selectedFolderPath: PropTypes.string,
};
export { FileExplorer };