@datarecce/ui 0.1.22 → 0.1.24

package/dist/{state-BjKRZMwY.js → state-Ct-DP81O.js}

@@ -1091,8 +1091,8 @@ async function getModelInfo(model) {
 
 //#endregion
 //#region recce-source/js/src/lib/api/cll.ts
-async function getCll(input) {
-	return (await axiosClient.post("/api/cll", input)).data;
+async function getCll(input, client = axiosClient) {
+	return (await client.post("/api/cll", input)).data;
 }
 
 //#endregion
@@ -1519,9 +1519,15 @@ function trackColumnLevelLineage(props) {
 function trackShareState(props) {
 	track("[Web] share_state", props);
 }
+function trackStateAction(props) {
+	track("[Web] state_action", props);
+}
 function trackCopyToClipboard(props) {
 	track("[Click] copy_to_clipboard", props);
 }
+function trackNavigation(props) {
+	track("[Web] navigation_change", props);
+}
 function trackLineageViewRender(props) {
 	track("[Web] lineage_view_render", props);
 }
@@ -1583,37 +1589,37 @@ function mutateAddKey(run) {
 	});
 	return run;
 }
-async function submitRun(type, params, options) {
+async function submitRun(type, params, options, client = axiosClient) {
 	const track_props = options?.trackProps ? { ...options.trackProps } : {};
 	if (getExperimentTrackingBreakingChangeEnabled()) track_props.breaking_change_analysis = true;
-	return (await axiosClient.post("/api/runs", {
+	return (await client.post("/api/runs", {
 		type,
 		params,
 		nowait: options?.nowait,
 		track_props
 	})).data;
 }
-async function getRun(runId) {
-	return (await axiosClient.get(`/api/runs/${runId}`)).data;
+async function getRun(runId, client = axiosClient) {
+	return (await client.get(`/api/runs/${runId}`)).data;
 }
-async function waitRun(runId, timeout) {
-	return mutateAddKey((await axiosClient.get(`/api/runs/${runId}/wait`, { params: { timeout } })).data);
+async function waitRun(runId, timeout, client = axiosClient) {
+	return mutateAddKey((await client.get(`/api/runs/${runId}/wait`, { params: { timeout } })).data);
 }
-async function cancelRun(runId) {
-	return await axiosClient.post(`/api/runs/${runId}/cancel`);
+async function cancelRun(runId, client = axiosClient) {
+	return await client.post(`/api/runs/${runId}/cancel`);
 }
-async function submitRunFromCheck(checkId, options) {
-	return (await axiosClient.post(`/api/checks/${checkId}/run`, { nowait: options?.nowait })).data;
+async function submitRunFromCheck(checkId, options, client = axiosClient) {
+	return (await client.post(`/api/checks/${checkId}/run`, { nowait: options?.nowait })).data;
 }
-async function searchRuns(type, params, limit) {
-	return (await axiosClient.post(`/api/runs/search`, {
+async function searchRuns(type, params, limit, client = axiosClient) {
+	return (await client.post(`/api/runs/search`, {
 		type,
 		params,
 		limit
 	})).data;
 }
-async function listRuns() {
-	return (await axiosClient.get("/api/runs")).data;
+async function listRuns(client = axiosClient) {
+	return (await client.get("/api/runs")).data;
 }
 async function aggregateRuns(client = axiosClient) {
 	return (await client.post(`/api/runs/aggregate`, {})).data;
@@ -1621,20 +1627,20 @@ async function aggregateRuns(client = axiosClient) {
 
 //#endregion
 //#region recce-source/js/src/lib/api/adhocQuery.ts
-async function submitQuery(params, options) {
-	return await submitRun("query", params, options);
+async function submitQuery(params, options, client = axiosClient) {
+	return await submitRun("query", params, options, client);
 }
-async function submitQueryBase(params, options) {
-	return await submitRun("query_base", params, options);
+async function submitQueryBase(params, options, client = axiosClient) {
+	return await submitRun("query_base", params, options, client);
 }
-async function submitQueryDiff(params, options) {
-	return await submitRun("query_diff", params, options);
+async function submitQueryDiff(params, options, client = axiosClient) {
+	return await submitRun("query_diff", params, options, client);
 }
 
 //#endregion
 //#region recce-source/js/src/lib/api/lineagecheck.ts
-async function createLineageDiffCheck(viewOptions) {
-	return (await axiosClient.post("/api/checks", {
+async function createLineageDiffCheck(viewOptions, client = axiosClient) {
+	return (await client.post("/api/checks", {
 		type: "lineage_diff",
 		params: {},
 		view_options: viewOptions
@@ -1643,17 +1649,17 @@ async function createLineageDiffCheck(viewOptions) {
 
 //#endregion
 //#region recce-source/js/src/lib/api/profile.ts
-async function submitProfileDiff(params, options) {
-	return await submitRun("profile_diff", params, options);
+async function submitProfileDiff(params, options, client = axiosClient) {
+	return await submitRun("profile_diff", params, options, client);
 }
 
 //#endregion
 //#region recce-source/js/src/lib/api/valuediff.ts
-async function submitValueDiff(params, options) {
-	return await submitRun("value_diff", params, options);
+async function submitValueDiff(params, options, client = axiosClient) {
+	return await submitRun("value_diff", params, options, client);
 }
-async function submitValueDiffDetail(params, options) {
-	return await submitRun("value_diff_detail", params, options);
+async function submitValueDiffDetail(params, options, client = axiosClient) {
+	return await submitRun("value_diff_detail", params, options, client);
 }
 
 //#endregion
@@ -2219,14 +2225,15 @@ function setKeepAliveCallback(callback) {
 * - Minimum 3 seconds between API calls
 * - Prevents concurrent API calls with a lock
 *
+* @param client - Optional axios instance for API configuration
 * @returns true if keep-alive was sent, false if throttled/skipped
 */
-async function sendKeepAlive() {
+async function sendKeepAlive(client = axiosClient) {
 	if (Date.now() - lastKeepAliveTime < MIN_KEEP_ALIVE_INTERVAL_MS) return false;
 	if (isSending) return false;
 	try {
 		isSending = true;
-		await axiosClient.post("/api/keep-alive");
+		await client.post("/api/keep-alive");
 		lastKeepAliveTime = Date.now();
 		if (onKeepAliveSuccess) onKeepAliveSuccess(lastKeepAliveTime);
 		return true;
@@ -2297,6 +2304,7 @@ const IDLE_DETECTION_CONFIG = {
 function useIdleDetection() {
 	const { data: instanceInfo, isLoading, isError } = useRecceInstanceInfo();
 	const isDisconnected = useIdleTimeoutSafe()?.isDisconnected ?? false;
+	const { apiClient } = useApiConfig();
 	const idleTimeout = instanceInfo?.idle_timeout;
 	const isEnabled = idleTimeout !== void 0 && idleTimeout > 0 && !isDisconnected;
 	debugLog("[Idle Detection] Instance info", {
@@ -2314,8 +2322,8 @@ function useIdleDetection() {
 	*/
 	const sendKeepAliveNow = (0, react.useCallback)(async () => {
 		if (document.hidden) return;
-		if (await sendKeepAlive()) debugLog("[Idle Detection] Keep-alive sent successfully", { timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-	}, []);
+		if (await sendKeepAlive(apiClient)) debugLog("[Idle Detection] Keep-alive sent successfully", { timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+	}, [apiClient]);
 	/**
 	* Handle any user activity event
 	* Attempts to send keep-alive (axios layer handles throttling)
@@ -3351,26 +3359,26 @@ function ProfileDiffForm({ params, onParamsChanged, setIsReadyToExecute }) {
 
 //#endregion
 //#region recce-source/js/src/lib/api/models.ts
-async function fetchModelRowCount(modelName) {
-	return (await axiosClient.get(`/api/models/${modelName}/row_count`)).data;
+async function fetchModelRowCount(modelName, client = axiosClient) {
+	return (await client.get(`/api/models/${modelName}/row_count`)).data;
 }
-async function queryModelRowCount(modelName) {
-	const { result } = await queryRowCount([modelName]);
+async function queryModelRowCount(modelName, client = axiosClient) {
+	const { result } = await queryRowCount([modelName], client);
 	return result[modelName];
 }
-async function queryRowCount(modelNames) {
+async function queryRowCount(modelNames, client = axiosClient) {
 	if (modelNames.length === 0) throw new Error("No model names provided");
-	const { run_id } = await submitRowCountDiff({ node_names: modelNames }, { nowait: true });
+	const { run_id } = await submitRowCountDiff({ node_names: modelNames }, { nowait: true }, client);
 	return {
 		runId: run_id,
-		result: (await waitRun(run_id)).result
+		result: (await waitRun(run_id, void 0, client)).result
 	};
 }
 
 //#endregion
 //#region recce-source/js/src/lib/api/rowcount.ts
-async function submitRowCountDiff(params, options) {
-	return await submitRun("row_count_diff", params, options);
+async function submitRowCountDiff(params, options, client = axiosClient) {
+	return await submitRun("row_count_diff", params, options, client);
 }
 
 //#endregion
@@ -5570,6 +5578,7 @@ const useCloseModalEffect = (onClose) => {
 	}, [onClose, (0, next_navigation.usePathname)()]);
 };
 function RecceActionContextProvider({ children }) {
+	const { apiClient } = useApiConfig();
 	const [action, setAction] = (0, react.useState)();
 	const [isModalOpen, setModalOpen] = (0, react.useState)(false);
 	const onModalOpen = (0, react.useCallback)(() => setModalOpen(true), []);
@@ -5597,7 +5606,7 @@ function RecceActionContextProvider({ children }) {
 			const session = (/* @__PURE__ */ new Date()).getTime().toString();
 			let lastRun = void 0;
 			if (options?.showLast) {
-				const runs = await searchRuns(type, params, 1);
+				const runs = await searchRuns(type, params, 1, apiClient);
 				if (runs.length === 1) lastRun = runs[0];
 			}
 			const run = findByRunType(type);
@@ -5608,7 +5617,7 @@ function RecceActionContextProvider({ children }) {
 				const { run_id } = await submitRun(type, params, {
 					nowait: true,
 					trackProps: options?.trackProps
-				});
+				}, apiClient);
 				await showRunId(run_id);
 				await queryClient.invalidateQueries({ queryKey: cacheKeys.runs() });
 				if (location.startsWith("/lineage")) setLocation("/lineage");
@@ -5638,7 +5647,8 @@ function RecceActionContextProvider({ children }) {
 		showRunId,
 		location,
 		setLocation,
-		queryClient
+		queryClient,
+		apiClient
 	]);
 	useCloseModalEffect(onModalClose);
 	const handleExecute = async (type, params) => {
@@ -5647,7 +5657,7 @@ function RecceActionContextProvider({ children }) {
 			const { run_id } = await submitRun(type, params, {
 				nowait: true,
 				trackProps: action?.options?.trackProps
-			});
+			}, apiClient);
 			await showRunId(run_id);
 		} catch (e) {
 			toaster.create({
@@ -8187,66 +8197,67 @@ const findByRunType = (runType) => {
 
 //#endregion
 //#region recce-source/js/src/lib/api/checks.ts
-async function createSimpleCheck() {
-	return (await axiosClient.post("/api/checks", { type: "simple" })).data;
+async function createSimpleCheck(client = axiosClient) {
+	return (await client.post("/api/checks", { type: "simple" })).data;
 }
-async function createCheckByRun(runId, viewOptions) {
+async function createCheckByRun(runId, viewOptions, client = axiosClient) {
 	const track_props = getExperimentTrackingBreakingChangeEnabled() ? { breaking_change_analysis: true } : {};
-	return (await axiosClient.post("/api/checks", {
+	return (await client.post("/api/checks", {
 		run_id: runId,
 		view_options: viewOptions,
 		track_props
 	})).data;
 }
-async function listChecks() {
-	return (await axiosClient.get("/api/checks")).data;
+async function listChecks(client = axiosClient) {
+	return (await client.get("/api/checks")).data;
 }
 function useChecks(enabled) {
+	const { apiClient } = useApiConfig();
 	return (0, _tanstack_react_query.useQuery)({
 		queryKey: cacheKeys.checks(),
-		queryFn: listChecks,
+		queryFn: () => listChecks(apiClient),
 		enabled
 	});
 }
-async function getCheck(checkId) {
-	return (await axiosClient.get(`/api/checks/${checkId}`)).data;
+async function getCheck(checkId, client = axiosClient) {
+	return (await client.get(`/api/checks/${checkId}`)).data;
 }
-async function updateCheck(checkId, payload) {
-	return (await axiosClient.patch(`/api/checks/${checkId}`, payload)).data;
+async function updateCheck(checkId, payload, client = axiosClient) {
+	return (await client.patch(`/api/checks/${checkId}`, payload)).data;
 }
-async function deleteCheck(checkId) {
-	return (await axiosClient.delete(`/api/checks/${checkId}`)).data;
+async function deleteCheck(checkId, client = axiosClient) {
+	return (await client.delete(`/api/checks/${checkId}`)).data;
 }
-async function reorderChecks(order) {
-	return await axiosClient.post("/api/checks/reorder", order);
+async function reorderChecks(order, client = axiosClient) {
+	return await client.post("/api/checks/reorder", order);
 }
-async function markAsPresetCheck(checkId) {
-	await axiosClient.post(`/api/checks/${checkId}/mark-as-preset`);
+async function markAsPresetCheck(checkId, client = axiosClient) {
+	await client.post(`/api/checks/${checkId}/mark-as-preset`);
 }
 
 //#endregion
 //#region recce-source/js/src/lib/api/state.ts
-async function saveAs(input) {
-	return (await axiosClient.post("/api/save-as", input)).data;
+async function saveAs(input, client = axiosClient) {
+	return (await client.post("/api/save-as", input)).data;
 }
-async function rename(input) {
-	return (await axiosClient.post("/api/rename", input)).data;
+async function rename(input, client = axiosClient) {
+	return (await client.post("/api/rename", input)).data;
 }
-async function exportState() {
-	return (await axiosClient.post("/api/export")).data;
+async function exportState(client = axiosClient) {
+	return (await client.post("/api/export")).data;
 }
-async function importState(file, checksOnly) {
+async function importState(file, checksOnly, client = axiosClient) {
 	const formData = new FormData();
 	formData.append("file", file);
 	formData.append("checks_only", (!!checksOnly).toString());
-	return (await axiosClient.post("/api/import", formData)).data;
+	return (await client.post("/api/import", formData)).data;
 }
-async function isStateSyncing() {
-	return (await axiosClient.get("/api/sync")).status === 208;
+async function isStateSyncing(client = axiosClient) {
+	return (await client.get("/api/sync")).status === 208;
 }
-async function syncState(input) {
+async function syncState(input, client = axiosClient) {
 	try {
-		const response = await axiosClient.post("/api/sync", input);
+		const response = await client.post("/api/sync", input);
 		if (response.status === 202) return { status: "accepted" };
 		if (response.status === 208) return { status: "syncing" };
 	} catch (error) {
@@ -8256,8 +8267,8 @@ async function syncState(input) {
 	}
 	throw new Error("Failed to sync state");
 }
-async function shareState() {
-	return (await axiosClient.post("/api/share")).data;
+async function shareState(client = axiosClient) {
+	return (await client.post("/api/share")).data;
 }
 
 //#endregion
@@ -8411,6 +8422,12 @@ Object.defineProperty(exports, 'QueryResultView', {
     return QueryResultView;
   }
 });
+Object.defineProperty(exports, 'RecceActionContext', {
+  enumerable: true,
+  get: function () {
+    return RecceActionContext;
+  }
+});
 Object.defineProperty(exports, 'RecceActionContextProvider', {
   enumerable: true,
   get: function () {
@@ -9011,6 +9028,12 @@ Object.defineProperty(exports, 'trackMultiNodesAction', {
     return trackMultiNodesAction;
   }
 });
+Object.defineProperty(exports, 'trackNavigation', {
+  enumerable: true,
+  get: function () {
+    return trackNavigation;
+  }
+});
 Object.defineProperty(exports, 'trackPreviewChange', {
   enumerable: true,
   get: function () {
@@ -9035,6 +9058,12 @@ Object.defineProperty(exports, 'trackSingleEnvironment', {
     return trackSingleEnvironment;
   }
 });
+Object.defineProperty(exports, 'trackStateAction', {
+  enumerable: true,
+  get: function () {
+    return trackStateAction;
+  }
+});
 Object.defineProperty(exports, 'union', {
   enumerable: true,
   get: function () {
@@ -9155,4 +9184,4 @@ Object.defineProperty(exports, 'waitRun', {
     return waitRun;
   }
 });
-//# sourceMappingURL=state-BjKRZMwY.js.map
+//# sourceMappingURL=state-Ct-DP81O.js.map