@burdenoff/microfe-bigconsole 2026.1016.2 → 2026.1017.1

package/dist/bigconsole/hooks/useDataSinkSubscription.d.ts

@@ -1,5 +1,4 @@
 import { DataSink } from '../types';
-
 interface UseDataSinkSubscriptionOptions {
     /** Specific DataSink ID to subscribe to (sink-level updates) */
     dataSinkId?: string;

package/dist/bigconsole/hooks/useDrilldown.d.ts

@@ -1,5 +1,4 @@
 import { Widget, WidgetDrilldown, NavigationMode } from '../types';
-
 /** Prefix for context parameters (clicked item data) */
 export declare const CONTEXT_PARAM_PREFIX = "ctx_";
 /** Prefix for filter parameters (global filters) */

package/dist/bigconsole/hooks/useDrilldownOperations.d.ts

@@ -1,5 +1,4 @@
 import { WidgetDrilldown, NavigationMode } from '../types';
-
 export interface CreateDrilldownInput {
     sourceWidgetId: string;
     targetDashboardId: string;

package/dist/bigconsole/hooks/useEventLogs.d.ts

@@ -1,9 +1,3 @@
-/**
- * useEventLogs Hook (v2.0)
- *
- * Hook for viewing and managing event logs.
- * Provides query operations for event history and retry functionality.
- */
 export type EventStatus = 'PENDING' | 'PROCESSING' | 'DELIVERED' | 'FAILED' | 'RETRYING' | 'IGNORED';
 export interface EventLog {
     id: string;

package/dist/bigconsole/hooks/useEventLogs.js

@@ -1,85 +1,177 @@
 import { ListEventLogsDocument as e, RetryEventDeliveryDocument as t } from "../../generated/wspace-operations.js";
-import { useCallback as n, useState as r } from "react";
-import { useMutation as i, useQuery as a } from "@apollo/client/react";
+import { useQueryLifecycle as n } from "./useQueryLifecycle.js";
+import { EventStatus as r } from "../../generated/wspace-types.js";
+import { useCallback as i, useMemo as a, useRef as o, useState as s } from "react";
+import { useMutation as c, useQuery as l } from "@apollo/client/react";
 //#region src/bigconsole/hooks/useEventLogs.ts
-function o(o = {}) {
-	let { dashboardId: s, widgetId: c, eventName: l, status: u, pageSize: d = 20, skipFetch: f = !1, onLogsLoaded: p, onError: m } = o, [h, g] = r(null), [_, v] = r([]), { data: y, loading: b, fetchMore: x, refetch: S } = a(e, {
+function u(e) {
+	switch (e) {
+		case "PENDING": return r.Pending;
+		case "PROCESSING": return r.Processing;
+		case "DELIVERED": return r.Delivered;
+		case "FAILED": return r.Failed;
+		case "RETRYING": return r.Retrying;
+		case "IGNORED": return r.Ignored;
+	}
+}
+function d(e) {
+	switch (e.status) {
+		case r.Pending: return {
+			...e,
+			status: "PENDING"
+		};
+		case r.Processing: return {
+			...e,
+			status: "PROCESSING"
+		};
+		case r.Delivered: return {
+			...e,
+			status: "DELIVERED"
+		};
+		case r.Failed: return {
+			...e,
+			status: "FAILED"
+		};
+		case r.Retrying: return {
+			...e,
+			status: "RETRYING"
+		};
+		case r.Ignored: return {
+			...e,
+			status: "IGNORED"
+		};
+		default: throw Error("The event log returned an unsupported delivery status.");
+	}
+}
+function f(r = {}) {
+	let { dashboardId: f, widgetId: p, eventName: m, status: h, pageSize: g = 20, skipFetch: _ = !1, onLogsLoaded: v, onError: y } = r, [b, x] = s(null), S = o(null), C = JSON.stringify([
+		f,
+		p,
+		m,
+		h,
+		g
+	]), [w, T] = s(null), E = a(() => !_ && w?.scope === C ? w.logs : [], [
+		_,
+		w,
+		C
+	]), { data: D, dataState: O, observable: k, loading: A, fetchMore: j, refetch: M } = l(e, {
 		variables: {
-			dashboardId: s,
-			widgetId: c,
-			eventName: l,
-			status: u,
-			first: d
+			dashboardId: f,
+			widgetId: p,
+			eventName: m,
+			status: h === void 0 ? void 0 : u(h),
+			first: g
 		},
-		skip: f,
+		skip: _,
+		returnPartialData: !1,
+		notifyOnNetworkStatusChange: !0
+	}), N = n(k, C, !_, {
 		onCompleted: (e) => {
-			let t = e?.listEventLogs;
-			if (t?.edges) {
-				let e = t.edges.map((e) => e.node);
-				v(e), p?.(e);
-			}
+			x(null);
+			let t = e.listEventLogs.edges.map((e) => d(e.node));
+			T({
+				scope: C,
+				logs: t
+			}), v?.(t);
 		},
 		onError: (e) => {
-			g(e), m?.(e);
+			x(e), y?.(e);
 		}
-	}), C = y, [w, { loading: T }] = i(t), E = n(async () => {
-		let e = C?.listEventLogs?.pageInfo?.endCursor;
-		if (!(!e || !C?.listEventLogs?.pageInfo?.hasNextPage)) try {
-			let t = (await x({ variables: { after: e } })).data;
-			if (t?.listEventLogs?.edges) {
-				let e = t.listEventLogs.edges.map((e) => e.node);
-				v((t) => [...t, ...e]);
-			}
+	}), P = !_ && O === "complete" ? D : void 0, [F, { loading: I }] = c(t), L = i(async () => {
+		let e = P?.listEventLogs?.pageInfo?.endCursor;
+		if (!N() || S.current?.scope === C || !e || !P?.listEventLogs?.pageInfo?.hasNextPage) return;
+		let t = {
+			scope: C,
+			cursor: e
+		};
+		S.current = t;
+		try {
+			await j({
+				variables: { after: e },
+				updateQuery(e, { fetchMoreResult: n }) {
+					if (!N() || S.current !== t || !n) return e;
+					let r = e.listEventLogs, i = n.listEventLogs, a = new Map(r.edges.map((e) => [e.node.id, e]));
+					for (let e of i.edges) a.set(e.node.id, e);
+					return {
+						...n,
+						listEventLogs: {
+							...i,
+							edges: [...a.values()],
+							pageInfo: {
+								...i.pageInfo,
+								startCursor: r.pageInfo.startCursor,
+								hasPreviousPage: r.pageInfo.hasPreviousPage
+							}
+						}
+					};
+				}
+			});
 		} catch (e) {
-			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to load more logs");
-			g(t), m?.(t);
+			if (!N() || S.current !== t) return;
+			let n = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to load more logs");
+			x(n), y?.(n);
+		} finally {
+			S.current === t && (S.current = null);
 		}
 	}, [
+		P,
+		j,
+		y,
 		C,
-		x,
-		m
-	]), D = n(async (t) => {
+		N
+	]), R = i(() => {
+		let e = {
+			scope: C,
+			cursor: null
+		};
+		return S.current = e, M().finally(() => {
+			S.current === e && (S.current = null);
+		});
+	}, [M, C]), z = i(async (t) => {
 		try {
-			return (await w({
-				variables: { eventLogId: t },
+			let n = await F({
+				variables: { eventId: t },
 				refetchQueries: [{
 					query: e,
 					variables: {
-						dashboardId: s,
-						widgetId: c,
-						eventName: l,
-						status: u,
-						first: d
+						dashboardId: f,
+						widgetId: p,
+						eventName: m,
+						status: h === void 0 ? void 0 : u(h),
+						first: g
 					}
 				}]
-			})).data?.retryEventDelivery || null;
+			});
+			return n.data ? d(n.data.retryEventDelivery) : null;
 		} catch (e) {
+			if (!N()) return null;
 			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to retry delivery");
-			return g(t), m?.(t), null;
+			return x(t), y?.(t), null;
 		}
 	}, [
-		w,
-		s,
-		c,
-		l,
-		u,
-		d,
-		m
-	]), O = n(async (e) => _.find((t) => t.id === e) || null, [_]), k = C?.listEventLogs, A = _.length > 0 ? _ : k?.edges?.map((e) => e.node) || [], j = k?.totalCount || 0, M = k?.pageInfo?.hasNextPage || !1, N = k?.pageInfo?.endCursor || null;
+		F,
+		f,
+		p,
+		m,
+		h,
+		g,
+		y,
+		N
+	]), B = i(async (e) => E.find((t) => t.id === e) || null, [E]), V = P?.listEventLogs, H = E.length > 0 ? E : V?.edges?.map((e) => d(e.node)) || [], U = V?.totalCount || 0, W = V?.pageInfo?.hasNextPage || !1, G = V?.pageInfo?.endCursor || null;
 	return {
-		loading: b || T,
-		error: h,
-		logs: A,
-		totalCount: j,
-		hasMore: M,
-		endCursor: N,
-		loadMore: E,
-		retryDelivery: D,
-		getEventLog: O,
-		refetch: S
+		loading: A || I,
+		error: b,
+		logs: H,
+		totalCount: U,
+		hasMore: W,
+		endCursor: G,
+		loadMore: L,
+		retryDelivery: z,
+		getEventLog: B,
+		refetch: R
 	};
 }
-function s(e) {
+function p(e) {
 	let t = {
 		PENDING: "#f59e0b",
 		PROCESSING: "#3b82f6",
@@ -90,7 +182,7 @@ function s(e) {
 	};
 	return t[e] || t.PENDING;
 }
-function c(e) {
+function m(e) {
 	return {
 		PENDING: "Pending",
 		PROCESSING: "Processing",
@@ -100,7 +192,7 @@ function c(e) {
 		IGNORED: "Ignored"
 	}[e] || e;
 }
-function l(e) {
+function h(e) {
 	return {
 		PENDING: "⏳",
 		PROCESSING: "🔄",
@@ -111,4 +203,4 @@ function l(e) {
 	}[e] || "❓";
 }
 //#endregion
-export { o as default, s as getEventStatusColor, l as getEventStatusIcon, c as getEventStatusLabel };
+export { f as default, p as getEventStatusColor, h as getEventStatusIcon, m as getEventStatusLabel };

package/dist/bigconsole/hooks/useEventWebhooks.d.ts

@@ -1,9 +1,3 @@
-/**
- * useEventWebhooks Hook (v2.0)
- *
- * Hook for managing event webhook mappings.
- * Provides CRUD operations for configuring webhooks that receive widget events.
- */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 export interface RetryPolicy {
     maxRetries: number;

package/dist/bigconsole/hooks/useEventWebhooks.js

@@ -1,98 +1,133 @@
 import { CreateEventWebhookMappingDocument as e, DeleteEventWebhookMappingDocument as t, ListEventWebhookMappingsDocument as n, TestWebhookMappingDocument as r, ToggleEventWebhookMappingDocument as i, UpdateEventWebhookMappingDocument as a } from "../../generated/wspace-operations.js";
-import { useCallback as o, useState as s } from "react";
-import { useMutation as c, useQuery as l } from "@apollo/client/react";
+import { useQueryLifecycle as o } from "./useQueryLifecycle.js";
+import { apiHttpMethod as s } from "./mutationInputEnums.js";
+import { useCallback as c, useMemo as l, useState as u } from "react";
+import { useMutation as d, useQuery as f } from "@apollo/client/react";
 //#region src/bigconsole/hooks/useEventWebhooks.ts
-function u(u = {}) {
-	let { dashboardId: d, widgetId: f, isActive: p, skipFetch: m = !1, onWebhooksLoaded: h, onError: g } = u, [_, v] = s(null), { data: y, loading: b, refetch: x } = l(n, {
+function p(e) {
+	let t = e.headers === null ? null : {};
+	if (t !== null && e.headers !== null) for (let [n, r] of Object.entries(e.headers)) {
+		if (typeof r != "string") throw Error("The webhook returned an invalid header value.");
+		t[n] = r;
+	}
+	return {
+		...e,
+		headers: t
+	};
+}
+function m(m = {}) {
+	let { dashboardId: h, widgetId: g, isActive: _, skipFetch: v = !1, onWebhooksLoaded: y, onError: b } = m, [x, S] = u(null), { data: C, dataState: w, observable: T, loading: E, refetch: D } = f(n, {
 		variables: {
-			dashboardId: d,
-			widgetId: f,
-			isActive: p
+			dashboardId: h,
+			widgetId: g,
+			isActive: _
 		},
-		skip: m,
+		skip: v,
+		returnPartialData: !1,
+		notifyOnNetworkStatusChange: !0
+	}), O = o(T, JSON.stringify([
+		h,
+		g,
+		_
+	]), !v, {
 		onCompleted: (e) => {
-			let t = e?.listEventWebhookMappings;
-			t && h?.(t);
+			S(null);
+			let t;
+			try {
+				t = e.listEventWebhookMappings.map(p);
+			} catch {
+				let e = /* @__PURE__ */ Error("The webhook returned an invalid header value.");
+				S(e), b?.(e);
+				return;
+			}
+			y?.(t);
 		},
 		onError: (e) => {
-			v(e), g?.(e);
+			S(e), b?.(e);
 		}
-	}), [S, { loading: C }] = c(e), [w, { loading: T }] = c(a), [E, { loading: D }] = c(t), [O, { loading: k }] = c(i), [A, { loading: j }] = c(r), M = o(async (e) => {
+	}), [k, { loading: A }] = d(e), [j, { loading: M }] = d(a), [N, { loading: P }] = d(t), [F, { loading: I }] = d(i), [L, { loading: R }] = d(r), z = c(async (e) => {
 		try {
-			return (await S({
-				variables: { input: e },
+			let { method: t, ...r } = e;
+			return (await k({
+				variables: { input: {
+					...r,
+					...t === void 0 ? {} : { method: s(t) }
+				} },
 				refetchQueries: [{
 					query: n,
 					variables: {
-						dashboardId: d,
-						widgetId: f,
-						isActive: p
+						dashboardId: h,
+						widgetId: g,
+						isActive: _
 					}
 				}]
 			})).data?.createEventWebhookMapping || null;
 		} catch (e) {
 			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to create webhook");
-			return v(t), g?.(t), null;
+			return S(t), b?.(t), null;
 		}
 	}, [
-		S,
-		d,
-		f,
-		p,
-		g
-	]), N = o(async (e) => {
+		k,
+		h,
+		g,
+		_,
+		b
+	]), B = c(async (e) => {
 		try {
-			let { id: t, ...r } = e;
-			return (await w({
+			let { id: t, method: r, ...i } = e;
+			return (await j({
 				variables: {
 					id: t,
-					input: r
+					input: {
+						...i,
+						...r === void 0 ? {} : { method: r === null ? null : s(r) }
+					}
 				},
 				refetchQueries: [{
 					query: n,
 					variables: {
-						dashboardId: d,
-						widgetId: f,
-						isActive: p
+						dashboardId: h,
+						widgetId: g,
+						isActive: _
 					}
 				}]
 			})).data?.updateEventWebhookMapping || null;
 		} catch (e) {
 			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to update webhook");
-			return v(t), g?.(t), null;
+			return S(t), b?.(t), null;
 		}
 	}, [
-		w,
-		d,
-		f,
-		p,
-		g
-	]), P = o(async (e) => {
+		j,
+		h,
+		g,
+		_,
+		b
+	]), V = c(async (e) => {
 		try {
-			return await E({
+			return await N({
 				variables: { id: e },
 				refetchQueries: [{
 					query: n,
 					variables: {
-						dashboardId: d,
-						widgetId: f,
-						isActive: p
+						dashboardId: h,
+						widgetId: g,
+						isActive: _
 					}
 				}]
 			}), !0;
 		} catch (e) {
 			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to delete webhook");
-			return v(t), g?.(t), !1;
+			return S(t), b?.(t), !1;
 		}
 	}, [
-		E,
-		d,
-		f,
-		p,
-		g
-	]), F = o(async (e, t) => {
+		N,
+		h,
+		g,
+		_,
+		b
+	]), H = c(async (e, t) => {
 		try {
-			return (await O({
+			return (await F({
 				variables: {
 					id: e,
 					isActive: t
@@ -100,41 +135,66 @@ function u(u = {}) {
 				refetchQueries: [{
 					query: n,
 					variables: {
-						dashboardId: d,
-						widgetId: f,
-						isActive: p
+						dashboardId: h,
+						widgetId: g,
+						isActive: _
 					}
 				}]
 			})).data?.toggleEventWebhookMapping || null;
 		} catch (e) {
 			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to toggle webhook");
-			return v(t), g?.(t), null;
+			return S(t), b?.(t), null;
 		}
 	}, [
-		O,
-		d,
-		f,
-		p,
-		g
-	]), I = o(async (e) => {
+		F,
+		h,
+		g,
+		_,
+		b
+	]), U = c(async (e) => {
 		try {
-			return (await A({ variables: { id: e } })).data?.testWebhookMapping || null;
+			return (await L({ variables: { id: e } })).data?.testWebhookMapping || null;
 		} catch (e) {
 			let t = e instanceof Error ? e : /* @__PURE__ */ Error("Failed to test webhook");
-			return v(t), g?.(t), null;
+			return S(t), b?.(t), null;
 		}
-	}, [A, g]);
+	}, [L, b]), W = E || A || M || P || I || R, G = !v && w === "complete" ? C : void 0, K = l(() => {
+		try {
+			return {
+				webhooks: G?.listEventWebhookMappings.map(p) ?? [],
+				error: null
+			};
+		} catch {
+			return {
+				webhooks: [],
+				error: /* @__PURE__ */ Error("The webhook returned an invalid header value.")
+			};
+		}
+	}, [G]), q = K.webhooks, J = c(async () => {
+		let e = await D();
+		if (!O() || !e.data) return {};
+		try {
+			return { data: { listEventWebhookMappings: e.data.listEventWebhookMappings.map(p) } };
+		} catch {
+			let e = /* @__PURE__ */ Error("The webhook returned an invalid header value.");
+			throw S(e), b?.(e), e;
+		}
+	}, [
+		D,
+		O,
+		b
+	]);
 	return {
-		loading: b || C || T || D || k || j,
-		error: _,
-		webhooks: y?.listEventWebhookMappings || [],
-		createWebhook: M,
-		updateWebhook: N,
-		deleteWebhook: P,
-		toggleWebhook: F,
-		testWebhook: I,
-		refetch: o(async () => await x() ?? {}, [x])
+		loading: W,
+		error: K.error ?? x,
+		webhooks: q,
+		createWebhook: z,
+		updateWebhook: B,
+		deleteWebhook: V,
+		toggleWebhook: H,
+		testWebhook: U,
+		refetch: J
 	};
 }
 //#endregion
-export { u as default };
+export { m as default };

package/dist/bigconsole/hooks/useInstalledWidgets.d.ts

@@ -1,5 +1,4 @@
 import { WidgetDefinition } from '../components/widgets/WidgetRegistry';
-
 export interface UseInstalledWidgetsParams {
     workspaceId?: string;
     apiGatewayUrl?: string;

package/dist/bigconsole/hooks/useModalFocusTrap.d.ts

@@ -1,5 +1,4 @@
 import { RefObject } from 'react';
-
 /**
  * Focusable descendants in DOM order, minus anything not actually reachable —
  * `getClientRects()` drops `display:none` / `hidden` subtrees, which matters

package/dist/bigconsole/hooks/usePageOperations.d.ts

@@ -1,5 +1,4 @@
 import { DashboardPage } from '../types';
-
 /** PageLayout enum values matching GraphQL schema */
 export type PageLayout = 'GRID' | 'FLEX' | 'FREEFORM';
 interface CreatePageInput {

package/dist/bigconsole/hooks/useParserOperations.d.ts

@@ -1,5 +1,4 @@
 import { Parser, ParserType, ParserStatus } from '../types';
-
 interface UseParserOperationsOptions {
     consoleId?: string;
     skipFetch?: boolean;

package/dist/bigconsole/hooks/usePipelineOperations.d.ts

@@ -1,5 +1,4 @@
 import { Pipeline, PipelineStage, PipelineStatus, PipelineExecution, StageErrorHandling, ParserType } from '../types';
-
 interface UsePipelineOperationsOptions {
     consoleId?: string;
     skipFetch?: boolean;

package/dist/bigconsole/hooks/useQueryLifecycle.d.ts

@@ -0,0 +1,8 @@
+import { DataValue, ObservableQuery, OperationVariables } from '@apollo/client';
+interface Callbacks<TData> {
+    onCompleted?: (data: DataValue.Complete<TData>) => void;
+    onError?: (error: Error) => void;
+}
+/** Observe the existing Apollo4 query; do not create a second query or transport. */
+export declare function useQueryLifecycle<TData, TVariables extends OperationVariables>(observable: ObservableQuery<TData, TVariables>, scope: string, enabled: boolean, callbacks: Callbacks<TData>): () => boolean;
+export {};