@elqnt/kg 3.0.0 → 3.0.2

package/dist/chunk-BP2I7KWY.js

@@ -0,0 +1,1031 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkCNWOI7LXjs = require('./chunk-CNWOI7LX.js');
+
+
+var _chunkWYRCAPY4js = require('./chunk-WYRCAPY4.js');
+
+// hooks/use-graphs.ts
+var _react = require('react');
+var _hooks = require('@elqnt/api-client/hooks');
+
+// hooks/use-options-ref.ts
+
+function useOptionsRef(options) {
+  const ref = _react.useRef.call(void 0, options);
+  _react.useEffect.call(void 0, () => {
+    ref.current = options;
+  }, [options]);
+  return ref;
+}
+
+// hooks/use-graphs.ts
+function useGraphs(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: listGraphs,
+    loading: listLoading,
+    error: listError
+  } = _hooks.useApiAsync.call(void 0, 
+    () => _chunkCNWOI7LXjs.listGraphsApi.call(void 0, optionsRef.current),
+    (data) => data.graphs || [],
+    []
+  );
+  const {
+    execute: getGraphInternal,
+    loading: getLoading,
+    error: getError
+  } = _hooks.useApiAsync.call(void 0, 
+    (graphId) => _chunkCNWOI7LXjs.getGraphApi.call(void 0, graphId, optionsRef.current),
+    (data) => data.graph || null,
+    null
+  );
+  const getGraph = _react.useCallback.call(void 0, (graphId) => getGraphInternal(graphId), [getGraphInternal]);
+  const {
+    execute: createGraphInternal,
+    loading: createLoading,
+    error: createError
+  } = _hooks.useApiAsync.call(void 0, 
+    (graph) => _chunkCNWOI7LXjs.createGraphApi.call(void 0, graph, optionsRef.current),
+    (data) => data.graph || null,
+    null
+  );
+  const createGraph = _react.useCallback.call(void 0, 
+    (graph) => createGraphInternal(graph),
+    [createGraphInternal]
+  );
+  const {
+    execute: updateGraphInternal,
+    loading: updateLoading,
+    error: updateError
+  } = _hooks.useApiAsync.call(void 0, 
+    (graphId, updates) => _chunkCNWOI7LXjs.updateGraphApi.call(void 0, graphId, updates, optionsRef.current),
+    (data) => data.graph || null,
+    null
+  );
+  const updateGraph = _react.useCallback.call(void 0, 
+    (graphId, updates) => updateGraphInternal(graphId, updates),
+    [updateGraphInternal]
+  );
+  const {
+    execute: deleteGraphInternal,
+    loading: deleteLoading,
+    error: deleteError
+  } = _hooks.useApiAsync.call(void 0, 
+    (graphId) => _chunkCNWOI7LXjs.deleteGraphApi.call(void 0, graphId, optionsRef.current),
+    (data) => _nullishCoalesce(data.success, () => ( true)),
+    false
+  );
+  const deleteGraph = _react.useCallback.call(void 0, 
+    (graphId) => deleteGraphInternal(graphId),
+    [deleteGraphInternal]
+  );
+  const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading;
+  const error = listError || getError || createError || updateError || deleteError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listGraphs,
+      getGraph,
+      createGraph,
+      updateGraph,
+      deleteGraph
+    }),
+    [loading, error, listGraphs, getGraph, createGraph, updateGraph, deleteGraph]
+  );
+}
+
+// hooks/use-kg-query.ts
+
+
+function useKGQuery(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: queryInternal,
+    loading: queryLoading,
+    error: queryError
+  } = _hooks.useApiAsync.call(void 0, 
+    (queryParams) => _chunkCNWOI7LXjs.queryGraphApi.call(void 0, queryParams, optionsRef.current),
+    (data) => data,
+    null
+  );
+  const query = _react.useCallback.call(void 0, 
+    (queryParams) => queryInternal(queryParams),
+    [queryInternal]
+  );
+  const {
+    execute: getLabels,
+    loading: labelsLoading,
+    error: labelsError
+  } = _hooks.useApiAsync.call(void 0, 
+    () => _chunkCNWOI7LXjs.getGraphLabelsApi.call(void 0, optionsRef.current),
+    (data) => data.labels || [],
+    []
+  );
+  const {
+    execute: getNodeInternal,
+    loading: nodeLoading,
+    error: nodeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (nodeId) => _chunkCNWOI7LXjs.getKGNodeApi.call(void 0, nodeId, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const getNode = _react.useCallback.call(void 0, (nodeId) => getNodeInternal(nodeId), [getNodeInternal]);
+  const {
+    execute: ingestNodeInternal,
+    loading: ingestLoading,
+    error: ingestError
+  } = _hooks.useApiAsync.call(void 0, 
+    (node) => _chunkCNWOI7LXjs.ingestKGNodeApi.call(void 0, node, optionsRef.current),
+    (data) => data.nodeId || null,
+    null
+  );
+  const ingestNode = _react.useCallback.call(void 0, 
+    (node) => ingestNodeInternal(node),
+    [ingestNodeInternal]
+  );
+  const {
+    execute: updateNodeInternal,
+    loading: updateLoading,
+    error: updateError
+  } = _hooks.useApiAsync.call(void 0, 
+    (nodeId, updates) => _chunkCNWOI7LXjs.updateKGNodeApi.call(void 0, nodeId, updates, optionsRef.current),
+    (data) => _nullishCoalesce(data.success, () => ( true)),
+    false
+  );
+  const updateNode = _react.useCallback.call(void 0, 
+    (nodeId, updates) => updateNodeInternal(nodeId, updates),
+    [updateNodeInternal]
+  );
+  const loading = queryLoading || labelsLoading || nodeLoading || ingestLoading || updateLoading;
+  const error = queryError || labelsError || nodeError || ingestError || updateError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      query,
+      getLabels,
+      getNode,
+      ingestNode,
+      updateNode
+    }),
+    [loading, error, query, getLabels, getNode, ingestNode, updateNode]
+  );
+}
+
+// hooks/use-kg-designer.ts
+
+
+function useKGDesigner(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: listNodes,
+    loading: listNodesLoading,
+    error: listNodesError
+  } = _hooks.useApiAsync.call(void 0, 
+    () => _chunkCNWOI7LXjs.listDesignerNodesApi.call(void 0, optionsRef.current),
+    (data) => data.nodes || [],
+    []
+  );
+  const {
+    execute: getNodeInternal,
+    loading: getNodeLoading,
+    error: getNodeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (label) => _chunkCNWOI7LXjs.getDesignerNodeApi.call(void 0, label, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const getNode = _react.useCallback.call(void 0, (label) => getNodeInternal(label), [getNodeInternal]);
+  const {
+    execute: createNodeInternal,
+    loading: createNodeLoading,
+    error: createNodeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (node) => _chunkCNWOI7LXjs.createDesignerNodeApi.call(void 0, node, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const createNode = _react.useCallback.call(void 0, 
+    (node) => createNodeInternal(node),
+    [createNodeInternal]
+  );
+  const {
+    execute: updateNodeInternal,
+    loading: updateNodeLoading,
+    error: updateNodeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (label, updates) => _chunkCNWOI7LXjs.updateDesignerNodeApi.call(void 0, label, updates, optionsRef.current),
+    (data) => data.node || null,
+    null
+  );
+  const updateNode = _react.useCallback.call(void 0, 
+    (label, updates) => updateNodeInternal(label, updates),
+    [updateNodeInternal]
+  );
+  const {
+    execute: deleteNodeInternal,
+    loading: deleteNodeLoading,
+    error: deleteNodeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (label) => _chunkCNWOI7LXjs.deleteDesignerNodeApi.call(void 0, label, optionsRef.current),
+    (data) => _nullishCoalesce(data.success, () => ( true)),
+    false
+  );
+  const deleteNode = _react.useCallback.call(void 0, (label) => deleteNodeInternal(label), [deleteNodeInternal]);
+  const {
+    execute: listEdges,
+    loading: listEdgesLoading,
+    error: listEdgesError
+  } = _hooks.useApiAsync.call(void 0, 
+    () => _chunkCNWOI7LXjs.listDesignerEdgesApi.call(void 0, optionsRef.current),
+    (data) => data.edges || [],
+    []
+  );
+  const {
+    execute: createEdgeInternal,
+    loading: createEdgeLoading,
+    error: createEdgeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (edge) => _chunkCNWOI7LXjs.createDesignerEdgeApi.call(void 0, edge, optionsRef.current),
+    (data) => data.edge || null,
+    null
+  );
+  const createEdge = _react.useCallback.call(void 0, 
+    (edge) => createEdgeInternal(edge),
+    [createEdgeInternal]
+  );
+  const {
+    execute: updateEdgeInternal,
+    loading: updateEdgeLoading,
+    error: updateEdgeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (label, updates) => _chunkCNWOI7LXjs.updateDesignerEdgeApi.call(void 0, label, updates, optionsRef.current),
+    (data) => data.edge || null,
+    null
+  );
+  const updateEdge = _react.useCallback.call(void 0, 
+    (label, updates) => updateEdgeInternal(label, updates),
+    [updateEdgeInternal]
+  );
+  const {
+    execute: deleteEdgeInternal,
+    loading: deleteEdgeLoading,
+    error: deleteEdgeError
+  } = _hooks.useApiAsync.call(void 0, 
+    (label) => _chunkCNWOI7LXjs.deleteDesignerEdgeApi.call(void 0, label, optionsRef.current),
+    (data) => _nullishCoalesce(data.success, () => ( true)),
+    false
+  );
+  const deleteEdge = _react.useCallback.call(void 0, (label) => deleteEdgeInternal(label), [deleteEdgeInternal]);
+  const loading = listNodesLoading || getNodeLoading || createNodeLoading || updateNodeLoading || deleteNodeLoading || listEdgesLoading || createEdgeLoading || updateEdgeLoading || deleteEdgeLoading;
+  const error = listNodesError || getNodeError || createNodeError || updateNodeError || deleteNodeError || listEdgesError || createEdgeError || updateEdgeError || deleteEdgeError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      // Nodes
+      listNodes,
+      getNode,
+      createNode,
+      updateNode,
+      deleteNode,
+      // Edges
+      listEdges,
+      createEdge,
+      updateEdge,
+      deleteEdge
+    }),
+    [
+      loading,
+      error,
+      listNodes,
+      getNode,
+      createNode,
+      updateNode,
+      deleteNode,
+      listEdges,
+      createEdge,
+      updateEdge,
+      deleteEdge
+    ]
+  );
+}
+
+// hooks/use-crawl-jobs.ts
+
+
+function useCrawlJobs(options) {
+  const optionsRef = useOptionsRef(options);
+  const {
+    execute: listJobsInternal,
+    loading: listLoading,
+    error: listError
+  } = _hooks.useApiAsync.call(void 0, 
+    (params) => _chunkCNWOI7LXjs.listCrawlJobsApi.call(void 0, { ...optionsRef.current, ...params }),
+    (data) => ({ jobs: data.jobs || [], total: data.total || 0 }),
+    { jobs: [], total: 0 }
+  );
+  const listJobs = _react.useCallback.call(void 0, 
+    (params) => listJobsInternal(params),
+    [listJobsInternal]
+  );
+  const {
+    execute: startJobInternal,
+    loading: startLoading,
+    error: startError
+  } = _hooks.useApiAsync.call(void 0, 
+    (params) => _chunkCNWOI7LXjs.startCrawlJobApi.call(void 0, params, optionsRef.current),
+    (data) => data.jobId || null,
+    null
+  );
+  const startJob = _react.useCallback.call(void 0, 
+    (params) => startJobInternal(params),
+    [startJobInternal]
+  );
+  const {
+    execute: getJobStatusInternal,
+    loading: statusLoading,
+    error: statusError
+  } = _hooks.useApiAsync.call(void 0, 
+    (jobId) => _chunkCNWOI7LXjs.getCrawlJobStatusApi.call(void 0, jobId, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const getJobStatus = _react.useCallback.call(void 0, 
+    (jobId) => getJobStatusInternal(jobId),
+    [getJobStatusInternal]
+  );
+  const {
+    execute: cancelJobInternal,
+    loading: cancelLoading,
+    error: cancelError
+  } = _hooks.useApiAsync.call(void 0, 
+    (jobId) => _chunkCNWOI7LXjs.cancelCrawlJobApi.call(void 0, jobId, optionsRef.current),
+    (data) => _nullishCoalesce(data.success, () => ( true)),
+    false
+  );
+  const cancelJob = _react.useCallback.call(void 0, (jobId) => cancelJobInternal(jobId), [cancelJobInternal]);
+  const {
+    execute: getCrawledPagesInternal,
+    loading: pagesLoading,
+    error: pagesError
+  } = _hooks.useApiAsync.call(void 0, 
+    (jobId) => _chunkCNWOI7LXjs.getCrawledPagesApi.call(void 0, jobId, optionsRef.current),
+    (data) => data.pages || [],
+    []
+  );
+  const getCrawledPages = _react.useCallback.call(void 0, 
+    (jobId) => getCrawledPagesInternal(jobId),
+    [getCrawledPagesInternal]
+  );
+  const loading = listLoading || startLoading || statusLoading || cancelLoading || pagesLoading;
+  const error = listError || startError || statusError || cancelError || pagesError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listJobs,
+      startJob,
+      getJobStatus,
+      cancelJob,
+      getCrawledPages
+    }),
+    [loading, error, listJobs, startJob, getJobStatus, cancelJob, getCrawledPages]
+  );
+}
+
+// hooks/use-quick-ingest.ts
+
+function useQuickIngest(options) {
+  const optionsRef = useOptionsRef(options);
+  const [items, setItems] = _react.useState.call(void 0, []);
+  const [isProcessing, setIsProcessing] = _react.useState.call(void 0, false);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const abortControllerRef = _react.useRef.call(void 0, null);
+  const uploadFile = _react.useCallback.call(void 0, async (file) => {
+    const tempId = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const placeholderItem = {
+      id: tempId,
+      type: "document",
+      name: file.name,
+      sizeBytes: file.size,
+      status: "uploading",
+      progress: 0
+    };
+    setItems((prev) => [...prev, placeholderItem]);
+    try {
+      const result = await optionsRef.current.onUploadFile(file);
+      if (result.error) {
+        throw new Error(result.error);
+      }
+      const uploadedItem = {
+        id: tempId,
+        type: "document",
+        name: file.name,
+        url: result.url,
+        sizeBytes: file.size,
+        pageCount: result.pageCount,
+        status: "ready",
+        progress: 100
+      };
+      setItems(
+        (prev) => prev.map((item) => item.id === tempId ? uploadedItem : item)
+      );
+      return uploadedItem;
+    } catch (err) {
+      setItems(
+        (prev) => prev.map(
+          (item) => item.id === tempId ? { ...item, status: "error", error: String(err) } : item
+        )
+      );
+      throw err;
+    }
+  }, []);
+  const addUrl = _react.useCallback.call(void 0, (url) => {
+    const id = `url_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const item = {
+      id,
+      type: "url",
+      name: url,
+      url,
+      status: "ready",
+      progress: 0
+    };
+    setItems((prev) => [...prev, item]);
+  }, []);
+  const removeItem = _react.useCallback.call(void 0, (id) => {
+    setItems((prev) => prev.filter((item) => item.id !== id));
+  }, []);
+  const clearQueue = _react.useCallback.call(void 0, () => {
+    setItems([]);
+    setError(null);
+  }, []);
+  const startIngestion = _react.useCallback.call(void 0, 
+    async (ingestionOptions) => {
+      const readyItems = items.filter((item) => item.status === "ready" && item.url);
+      if (readyItems.length === 0) {
+        setError("No items ready for ingestion");
+        return;
+      }
+      setError(null);
+      setIsProcessing(true);
+      abortControllerRef.current = new AbortController();
+      setItems(
+        (prev) => prev.map(
+          (item) => item.status === "ready" ? { ...item, status: "processing" } : item
+        )
+      );
+      try {
+        const request = {
+          items: readyItems.map((item) => ({
+            id: item.id,
+            type: item.type,
+            name: item.name,
+            url: item.url
+          })),
+          options: ingestionOptions,
+          graphId: optionsRef.current.graphId || "default"
+        };
+        await _chunkCNWOI7LXjs.startQuickIngestApi.call(void 0, request, optionsRef.current, (event) => {
+          switch (event.type) {
+            case "item_start":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? { ...item, status: "processing", progress: 0 } : item
+                )
+              );
+              break;
+            case "item_progress":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? { ...item, progress: event.progress || 0, progressText: event.text } : item
+                )
+              );
+              break;
+            case "item_complete":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? {
+                    ...item,
+                    status: "complete",
+                    progress: 100,
+                    result: {
+                      articlesCreated: event.articles,
+                      topicsCreated: event.topics,
+                      nodesCreated: event.nodesCreated,
+                      nodesByLabel: event.nodesByLabel
+                    }
+                  } : item
+                )
+              );
+              break;
+            case "item_error":
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.id === event.itemId ? { ...item, status: "error", error: event.error } : item
+                )
+              );
+              break;
+            case "job_complete":
+              setIsProcessing(false);
+              break;
+            case "error":
+              setError(event.message || event.error || "Unknown error");
+              setIsProcessing(false);
+              break;
+            case "cancelled":
+              setIsProcessing(false);
+              setItems(
+                (prev) => prev.map(
+                  (item) => item.status === "processing" ? { ...item, status: "ready" } : item
+                )
+              );
+              break;
+          }
+        });
+        setIsProcessing(false);
+      } catch (err) {
+        setError(String(err));
+        setIsProcessing(false);
+        setItems(
+          (prev) => prev.map(
+            (item) => item.status === "processing" ? { ...item, status: "ready" } : item
+          )
+        );
+      }
+    },
+    [items]
+  );
+  const cancelIngestion = _react.useCallback.call(void 0, () => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    setIsProcessing(false);
+    setItems(
+      (prev) => prev.map(
+        (item) => item.status === "processing" ? { ...item, status: "ready" } : item
+      )
+    );
+  }, []);
+  return _react.useMemo.call(void 0, 
+    () => ({
+      items,
+      isProcessing,
+      error,
+      uploadFile,
+      addUrl,
+      removeItem,
+      startIngestion,
+      cancelIngestion,
+      clearQueue
+    }),
+    [
+      items,
+      isProcessing,
+      error,
+      uploadFile,
+      addUrl,
+      removeItem,
+      startIngestion,
+      cancelIngestion,
+      clearQueue
+    ]
+  );
+}
+
+// hooks/use-full-ingest.ts
+
+function useFullIngest(options) {
+  const optionsRef = useOptionsRef(options);
+  const [sourceType, setSourceType] = _react.useState.call(void 0, null);
+  const [document, setDocument] = _react.useState.call(void 0, null);
+  const [crawlJob, setCrawlJob] = _react.useState.call(void 0, null);
+  const [selectedLabels, setSelectedLabels] = _react.useState.call(void 0, []);
+  const [extractedNodes, setExtractedNodes] = _react.useState.call(void 0, []);
+  const [extractedEdges, setExtractedEdges] = _react.useState.call(void 0, []);
+  const [isExtracting, setIsExtracting] = _react.useState.call(void 0, false);
+  const [extractionProgress, setExtractionProgress] = _react.useState.call(void 0, null);
+  const [isIngesting, setIsIngesting] = _react.useState.call(void 0, false);
+  const [ingestProgress, setIngestProgress] = _react.useState.call(void 0, null);
+  const [jobId, setJobId] = _react.useState.call(void 0, null);
+  const [error, setError] = _react.useState.call(void 0, null);
+  const transportRef = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    return () => {
+      if (transportRef.current) {
+        transportRef.current.disconnect();
+        transportRef.current = null;
+      }
+    };
+  }, []);
+  const uploadDocument = _react.useCallback.call(void 0, async (file) => {
+    setError(null);
+    try {
+      const { onUploadFile } = optionsRef.current;
+      if (onUploadFile) {
+        const result = await onUploadFile(file);
+        if (result.error) {
+          throw new Error(result.error);
+        }
+        setDocument({
+          url: result.url,
+          pageCount: result.pageCount || 0,
+          sizeBytes: file.size
+        });
+      } else {
+        const url = URL.createObjectURL(file);
+        setDocument({
+          url,
+          pageCount: 0,
+          sizeBytes: file.size
+        });
+      }
+      setSourceType("document");
+    } catch (err) {
+      setError(String(err));
+      throw err;
+    }
+  }, []);
+  const setDocumentUrl = _react.useCallback.call(void 0, 
+    (url, pageCount, sizeBytes) => {
+      setDocument({ url, pageCount, sizeBytes });
+      setSourceType("document");
+      setError(null);
+    },
+    []
+  );
+  const startCrawl = _react.useCallback.call(void 0, 
+    async (url, depth, maxPages) => {
+      setError(null);
+      try {
+        const response = await _chunkCNWOI7LXjs.startCrawlJobApi.call(void 0, 
+          { baseUrl: url, depth, maxPages },
+          optionsRef.current
+        );
+        if (!_optionalChain([response, 'access', _ => _.data, 'optionalAccess', _2 => _2.jobId])) {
+          throw new Error(response.error || "Failed to start crawl");
+        }
+        const pollInterval = setInterval(async () => {
+          const statusResponse = await _chunkCNWOI7LXjs.getCrawlJobStatusApi.call(void 0, 
+            response.data.jobId,
+            optionsRef.current
+          );
+          if (_optionalChain([statusResponse, 'access', _3 => _3.data, 'optionalAccess', _4 => _4.job])) {
+            setCrawlJob(statusResponse.data.job);
+            if (statusResponse.data.job.status === "completed" || statusResponse.data.job.status === "failed") {
+              clearInterval(pollInterval);
+              if (statusResponse.data.job.status === "failed") {
+                setError("Crawl job failed");
+              }
+            }
+          }
+        }, 2e3);
+        setSourceType("website");
+        setCrawlJob({
+          id: response.data.jobId,
+          baseUrl: url,
+          depth,
+          maxPages,
+          status: "pending",
+          pagesProcessed: 0,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (err) {
+        setError(String(err));
+        throw err;
+      }
+    },
+    []
+  );
+  const startExtraction = _react.useCallback.call(void 0, async () => {
+    if (!sourceType) {
+      setError("No source selected");
+      return;
+    }
+    if (selectedLabels.length === 0) {
+      setError("No labels selected");
+      return;
+    }
+    let sourceId;
+    if (sourceType === "document") {
+      if (!document) {
+        setError("No document uploaded");
+        return;
+      }
+      sourceId = document.url;
+    } else {
+      if (!crawlJob) {
+        setError("No crawl job");
+        return;
+      }
+      sourceId = crawlJob.id;
+    }
+    setError(null);
+    setIsExtracting(true);
+    setExtractedNodes([]);
+    setExtractedEdges([]);
+    setExtractionProgress(null);
+    try {
+      const request = {
+        sourceType,
+        sourceId,
+        labels: selectedLabels,
+        graphId: optionsRef.current.graphId || "default"
+      };
+      const response = await _chunkCNWOI7LXjs.startFullIngestExtractionApi.call(void 0, request, optionsRef.current);
+      if (!response.data) {
+        throw new Error(response.error || "Failed to start extraction");
+      }
+      const newJobId = response.data.jobId;
+      setJobId(newJobId);
+      const transport = _chunkWYRCAPY4js.createFullIngestTransport.call(void 0, { debug: options.debug });
+      await transport.connect(optionsRef.current);
+      transportRef.current = transport;
+      transport.on("progress", (event) => {
+        setExtractionProgress({
+          current: event.currentPage,
+          total: event.totalPages,
+          phase: "extracting"
+        });
+      });
+      transport.on("node", (event) => {
+        const node = {
+          id: event.id,
+          label: event.label,
+          fields: event.fields
+        };
+        setExtractedNodes((prev) => [...prev, node]);
+      });
+      transport.on("consolidating", (event) => {
+        setExtractionProgress((prev) => ({
+          current: _optionalChain([prev, 'optionalAccess', _5 => _5.current]) || 0,
+          total: _optionalChain([prev, 'optionalAccess', _6 => _6.total]) || 0,
+          phase: "consolidating",
+          message: event.message
+        }));
+      });
+      transport.on("consolidated", (event) => {
+        setExtractionProgress((prev) => ({
+          current: _optionalChain([prev, 'optionalAccess', _7 => _7.current]) || 0,
+          total: _optionalChain([prev, 'optionalAccess', _8 => _8.total]) || 0,
+          phase: "consolidating",
+          message: event.message
+        }));
+      });
+      transport.on("linking", (event) => {
+        setExtractionProgress((prev) => ({
+          current: _optionalChain([prev, 'optionalAccess', _9 => _9.current]) || 0,
+          total: _optionalChain([prev, 'optionalAccess', _10 => _10.total]) || 0,
+          phase: "linking",
+          message: event.message
+        }));
+      });
+      transport.on("edge", (event) => {
+        const edge = {
+          id: event.id,
+          fromLabel: event.fromLabel,
+          fromName: event.fromName,
+          toLabel: event.toLabel,
+          toName: event.toName,
+          edgeLabel: event.edgeLabel,
+          confidence: event.confidence
+        };
+        setExtractedEdges((prev) => [...prev, edge]);
+      });
+      transport.on("linked", (event) => {
+        setExtractionProgress((prev) => ({
+          current: _optionalChain([prev, 'optionalAccess', _11 => _11.current]) || 0,
+          total: _optionalChain([prev, 'optionalAccess', _12 => _12.total]) || 0,
+          phase: "linking",
+          message: event.message
+        }));
+      });
+      transport.on("complete", (event) => {
+        setExtractionProgress((prev) => ({
+          current: _optionalChain([prev, 'optionalAccess', _13 => _13.current]) || 0,
+          total: _optionalChain([prev, 'optionalAccess', _14 => _14.total]) || 0,
+          phase: "complete",
+          message: event.message
+        }));
+        setIsExtracting(false);
+        setJobId(null);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.on("error", (event) => {
+        setError(event.message);
+        setIsExtracting(false);
+        setJobId(null);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.subscribeToJob(newJobId);
+    } catch (err) {
+      setError(String(err));
+      setIsExtracting(false);
+      setJobId(null);
+    }
+  }, [sourceType, document, crawlJob, selectedLabels, options.debug]);
+  const cancelExtraction = _react.useCallback.call(void 0, async () => {
+    if (!jobId) return;
+    try {
+      await _chunkCNWOI7LXjs.cancelFullIngestExtractionApi.call(void 0, jobId, optionsRef.current);
+      if (transportRef.current) {
+        transportRef.current.disconnect();
+        transportRef.current = null;
+      }
+      setIsExtracting(false);
+      setJobId(null);
+    } catch (err) {
+      setError(String(err));
+    }
+  }, [jobId]);
+  const removeNode = _react.useCallback.call(void 0, (id) => {
+    setExtractedNodes((prev) => prev.filter((node) => node.id !== id));
+  }, []);
+  const updateNode = _react.useCallback.call(void 0, (id, fields) => {
+    setExtractedNodes(
+      (prev) => prev.map((node) => node.id === id ? { ...node, fields } : node)
+    );
+  }, []);
+  const removeEdge = _react.useCallback.call(void 0, (id) => {
+    setExtractedEdges((prev) => prev.filter((edge) => edge.id !== id));
+  }, []);
+  const ingestNodes = _react.useCallback.call(void 0, async () => {
+    if (!jobId) {
+      setError("No job ID - extraction must be started first");
+      return;
+    }
+    if (extractedNodes.length === 0) {
+      setError("No nodes to ingest");
+      return;
+    }
+    setError(null);
+    setIsIngesting(true);
+    setIngestProgress(null);
+    try {
+      const request = {
+        jobId
+      };
+      const response = await _chunkCNWOI7LXjs.ingestFullIngestNodesApi.call(void 0, request, optionsRef.current);
+      if (!response.data) {
+        throw new Error(response.error || "Failed to start ingestion");
+      }
+      const transport = _chunkWYRCAPY4js.createFullIngestTransport.call(void 0, { debug: options.debug });
+      await transport.connect(optionsRef.current);
+      transportRef.current = transport;
+      transport.on("ingest_progress", (event) => {
+        setIngestProgress({
+          currentNode: event.currentNode,
+          totalNodes: event.totalNodes,
+          currentEdge: event.currentEdge,
+          totalEdges: event.totalEdges,
+          message: event.message
+        });
+      });
+      transport.on("ingest_complete", (event) => {
+        setIngestProgress({
+          currentNode: event.nodesIngested,
+          totalNodes: event.nodesIngested,
+          currentEdge: event.edgesIngested,
+          totalEdges: event.edgesIngested,
+          message: event.message
+        });
+        setIsIngesting(false);
+        setExtractedNodes([]);
+        setExtractedEdges([]);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.on("error", (event) => {
+        setError(event.message);
+        setIsIngesting(false);
+        transport.disconnect();
+        transportRef.current = null;
+      });
+      transport.subscribeToJob(jobId);
+    } catch (err) {
+      setError(String(err));
+      setIsIngesting(false);
+      throw err;
+    }
+  }, [jobId, extractedNodes, options.debug]);
+  const reset = _react.useCallback.call(void 0, () => {
+    if (transportRef.current) {
+      transportRef.current.disconnect();
+      transportRef.current = null;
+    }
+    setSourceType(null);
+    setDocument(null);
+    setCrawlJob(null);
+    setSelectedLabels([]);
+    setExtractedNodes([]);
+    setExtractedEdges([]);
+    setIsExtracting(false);
+    setExtractionProgress(null);
+    setIsIngesting(false);
+    setIngestProgress(null);
+    setJobId(null);
+    setError(null);
+  }, []);
+  return _react.useMemo.call(void 0, 
+    () => ({
+      sourceType,
+      document,
+      crawlJob,
+      selectedLabels,
+      extractedNodes,
+      extractedEdges,
+      isExtracting,
+      extractionProgress,
+      isIngesting,
+      ingestProgress,
+      jobId,
+      error,
+      uploadDocument,
+      setDocumentUrl,
+      startCrawl,
+      setSelectedLabels,
+      startExtraction,
+      cancelExtraction,
+      removeNode,
+      updateNode,
+      removeEdge,
+      ingestNodes,
+      reset
+    }),
+    [
+      sourceType,
+      document,
+      crawlJob,
+      selectedLabels,
+      extractedNodes,
+      extractedEdges,
+      isExtracting,
+      extractionProgress,
+      isIngesting,
+      ingestProgress,
+      jobId,
+      error,
+      uploadDocument,
+      setDocumentUrl,
+      startCrawl,
+      startExtraction,
+      cancelExtraction,
+      removeNode,
+      updateNode,
+      removeEdge,
+      ingestNodes,
+      reset
+    ]
+  );
+}
+
+// hooks/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+exports.useOptionsRef = useOptionsRef; exports.useGraphs = useGraphs; exports.useKGQuery = useKGQuery; exports.useKGDesigner = useKGDesigner; exports.useCrawlJobs = useCrawlJobs; exports.useQuickIngest = useQuickIngest; exports.useFullIngest = useFullIngest; exports.useApiAsync = _hooks.useApiAsync; exports.useAsync = _hooks.useAsync;
+//# sourceMappingURL=chunk-BP2I7KWY.js.map