@betterinternship/components 2.9.6 → 2.9.7

package/dist/hooks/useClientProcess.js

@@ -1,255 +1,255 @@
-"use client";
-import { jsx } from 'react/jsx-runtime';
-import { createContext, useRef, useState, useEffect, useContext } from 'react';
-import { useQueryClient, useQueries } from '@tanstack/react-query';
-import { config } from '../config.js';
-
-/**
- * The orchestrator service to get the process from.
- *
- * @param processId
- * @returns
- */
-const processStatusChecker = (processId) => {
-    if (!processId)
-        return { process: null };
-    return fetch(`${config.orchestratorApi}/${encodeURIComponent(processId)}`, {
-        method: 'GET',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-    }).then((response) => response.json());
-};
-/**
- * This fetches from the callback endpoint.
- *
- * @param processId
- * @returns
- */
-const processCallbackResultFetcher = (processId, processName, processCallbackUrl) => fetch(`${processCallbackUrl}`, {
-    method: 'POST',
-    headers: {
-        'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-        processId,
-        processName,
-    }),
-}).then((response) => response.json());
-/**
- * We need a context to keep track of all client processes.
- * This helps us manage the state of the toasts as well.
- */
-const clientProcessesContext = createContext({});
-/**
- * This should be at the root layout.
- *
- * @context
- */
-const ClientProcessesProvider = ({ children, }) => {
-    const queryClient = useQueryClient();
-    const clientProcessAttempts = useRef({});
-    const [clientProcessDtos, setClientProcessDtos] = useState({});
-    // Populates the state object with cached data on mount
-    useEffect(() => {
-        setClientProcessDtos((oldData) => {
-            if (Object.keys(oldData).length > 0)
-                return oldData;
-            const cachedClientProcesses = queryClient
-                .getQueryCache()
-                .findAll({ queryKey: ['.__process'], exact: false });
-            const seededClientProcesses = {};
-            for (const query of cachedClientProcesses) {
-                const processId = query.queryKey[2];
-                if (typeof processId !== 'string')
-                    continue;
-                const data = query.state.data;
-                if (!data?.dto || !data?.metadata)
-                    continue;
-                seededClientProcesses[processId] = {
-                    dto: data.dto,
-                    metadata: data.metadata,
-                    options: data.options,
-                };
-            }
-            return { ...oldData, ...seededClientProcesses };
-        });
-    }, [queryClient]);
-    // The query for all the processes, pending and sht
-    const clientProcesses = useQueries({
-        queries: Object.entries(clientProcessDtos).map(([processId, { dto, metadata, options }]) => ({
-            staleTime: Infinity,
-            gcTime: 3 * 60 * 1000,
-            refetchOnWindowFocus: true,
-            refetchIntervalInBackground: true,
-            refetchOnMount: true,
-            refetchOnReconnect: true,
-            queryKey: ['.__process', metadata.filterKey, processId],
-            queryFn: async () => {
-                if (!processId)
-                    throw new Error('No processId');
-                const { process } = await processStatusChecker(processId);
-                // Handled! Return the proper response too
-                if (process?.status === 'handled') {
-                    const result = await processCallbackResultFetcher(process.id, process.name, dto.processCallbackUrl);
-                    // Log and call runner
-                    console.warn(`Handled ${process.name} (${process.id})!`);
-                    options?.onSuccess?.(process.id, process.name, result);
-                    return {
-                        dto,
-                        metadata,
-                        options,
-                        success: true,
-                        pending: false,
-                        result,
-                    };
-                }
-                // Pending or failed
-                if (process?.status === 'pending') {
-                    console.log(`Running process ${process.name} (${process.id})...`);
-                    options?.onLoading?.(process.id, process.name);
-                    return { dto, metadata, options, pending: true };
-                }
-                else if (process?.status === 'failed') {
-                    console.error(`Failed ${process.name} (${process.id}) - ${process.error}.`);
-                    return {
-                        dto,
-                        metadata,
-                        options,
-                        success: false,
-                        pending: false,
-                        error: process.error,
-                    };
-                }
-                // Return null since no response
-                return { dto, metadata, options, pending: true };
-            },
-            // Returns the next interval length to use to wait for fetch
-            refetchInterval: (query) => {
-                const data = query.state.data;
-                if (data?.success !== undefined)
-                    return false;
-                // If not defined, init to 0
-                if (!clientProcessAttempts.current[processId])
-                    clientProcessAttempts.current[processId] = 0;
-                const interval = Math.min(500 * 2 ** clientProcessAttempts.current[processId], 10000);
-                clientProcessAttempts.current[processId] += 1;
-                return interval;
-            },
-        })),
-    });
-    /**
-     * Registers a new process to handle
-     *
-     * @param processId
-     * @param processCallbackDto
-     * @param options
-     */
-    const registerProcess = (processId, processCallbackDto, metadata, options) => {
-        setClientProcessDtos({
-            ...clientProcessDtos,
-            [processId]: { dto: processCallbackDto, metadata, options },
-        });
-    };
-    /**
-     * Retrieves a process
-     *
-     * @param processId
-     * @returns
-     */
-    const getProcess = (processId) => {
-        const clientProcess = clientProcesses.find((clientProcess) => clientProcess.data?.dto?.processId === processId)?.data ?? null;
-        return clientProcess ?? null;
-    };
-    /**
-     * Filters processes by the provided attribute.
-     *
-     * @param filterKey
-     */
-    const filterProcesses = (filterKey) => {
-        return clientProcesses
-            .filter((clientProcess) => !!clientProcess.data?.dto)
-            .map((clientProcess) => clientProcess.data)
-            .filter((clientProcessData) => clientProcessData?.metadata.filterKey === filterKey);
-    };
-    /**
-     * Refreshes the cache and invalidates all related processes.
-     */
-    const invalidateBasedOnResult = async (filter, invalidator) => {
-        await queryClient.invalidateQueries({
-            queryKey: ['.__process', filter],
-            exact: false,
-        });
-        const cachedClientProcesses = queryClient
-            .getQueryCache()
-            .findAll({ queryKey: ['.__process', filter], exact: false });
-        for (const query of cachedClientProcesses) {
-            const processId = query.queryKey[2];
-            if (typeof processId !== 'string')
-                continue;
-            const data = query.state.data;
-            if (!data.result)
-                continue;
-            // If invalidator says we gotta clear the cache, we clear it
-            if (invalidator && invalidator?.(data.result)) {
-                queryClient.removeQueries({ queryKey: query.queryKey });
-            }
-        }
-    };
-    return (jsx(clientProcessesContext.Provider, { value: {
-            registerProcess,
-            getProcess,
-            filterProcesses,
-            invalidateBasedOnResult,
-        }, children: children }));
-};
-/**
- * A simpler version, where u just pass the async function that returns process data.
- *
- * @param caller
- * @returns
- */
-function useClientProcess({ caller, invalidator, filterKey, onLoading, onSuccess, onFailure, }) {
-    const clientProcessesApi = useContext(clientProcessesContext);
-    // Note that the exposed function doesn't return process ids
-    // Client should be oblivious to those
-    // Abstraction BABY!
-    const wrappedCaller = async (inputs, metadata) => {
-        const response = await caller?.(inputs);
-        if (response) {
-            clientProcessesApi.registerProcess(response.processId, response, { filterKey, metadata }, {
-                onLoading,
-                onSuccess,
-                onFailure,
-            });
-            return {
-                id: response.processId,
-                success: response.success,
-                message: response.message,
-            };
-        }
-        return {
-            id: null,
-            success: false,
-            message: 'No `caller` specified for useClientProcess().',
-        };
-    };
-    return {
-        run: wrappedCaller,
-        get: (id) => clientProcessesApi.getProcess(id),
-        getAll: () => clientProcessesApi.filterProcesses(filterKey),
-        getAllPending: () => clientProcessesApi
-            .filterProcesses(filterKey)
-            .filter((process) => process.pending),
-        getAllHandled: () => clientProcessesApi
-            .filterProcesses(filterKey)
-            .filter((process) => process.success),
-        getAllFailed: () => clientProcessesApi
-            .filterProcesses(filterKey)
-            .filter((process) => !process.success),
-        refreshCache: () => clientProcessesApi.invalidateBasedOnResult(filterKey, invalidator),
-    };
-}
-
-export { ClientProcessesProvider, useClientProcess };
-//# sourceMappingURL=useClientProcess.js.map
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useRef, useState, useEffect, useContext } from 'react';
+import { useQueryClient, useQueries } from '@tanstack/react-query';
+import { config } from '../config.js';
+
+/**
+ * The orchestrator service to get the process from.
+ *
+ * @param processId
+ * @returns
+ */
+const processStatusChecker = (processId) => {
+    if (!processId)
+        return { process: null };
+    return fetch(`${config.orchestratorApi}/${encodeURIComponent(processId)}`, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    }).then((response) => response.json());
+};
+/**
+ * This fetches from the callback endpoint.
+ *
+ * @param processId
+ * @returns
+ */
+const processCallbackResultFetcher = (processId, processName, processCallbackUrl) => fetch(`${processCallbackUrl}`, {
+    method: 'POST',
+    headers: {
+        'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+        processId,
+        processName,
+    }),
+}).then((response) => response.json());
+/**
+ * We need a context to keep track of all client processes.
+ * This helps us manage the state of the toasts as well.
+ */
+const clientProcessesContext = createContext({});
+/**
+ * This should be at the root layout.
+ *
+ * @context
+ */
+const ClientProcessesProvider = ({ children, }) => {
+    const queryClient = useQueryClient();
+    const clientProcessAttempts = useRef({});
+    const [clientProcessDtos, setClientProcessDtos] = useState({});
+    // Populates the state object with cached data on mount
+    useEffect(() => {
+        setClientProcessDtos((oldData) => {
+            if (Object.keys(oldData).length > 0)
+                return oldData;
+            const cachedClientProcesses = queryClient
+                .getQueryCache()
+                .findAll({ queryKey: ['.__process'], exact: false });
+            const seededClientProcesses = {};
+            for (const query of cachedClientProcesses) {
+                const processId = query.queryKey[2];
+                if (typeof processId !== 'string')
+                    continue;
+                const data = query.state.data;
+                if (!data?.dto || !data?.metadata)
+                    continue;
+                seededClientProcesses[processId] = {
+                    dto: data.dto,
+                    metadata: data.metadata,
+                    options: data.options,
+                };
+            }
+            return { ...oldData, ...seededClientProcesses };
+        });
+    }, [queryClient]);
+    // The query for all the processes, pending and sht
+    const clientProcesses = useQueries({
+        queries: Object.entries(clientProcessDtos).map(([processId, { dto, metadata, options }]) => ({
+            staleTime: Infinity,
+            gcTime: 3 * 60 * 1000,
+            refetchOnWindowFocus: true,
+            refetchIntervalInBackground: true,
+            refetchOnMount: true,
+            refetchOnReconnect: true,
+            queryKey: ['.__process', metadata.filterKey, processId],
+            queryFn: async () => {
+                if (!processId)
+                    throw new Error('No processId');
+                const { process } = await processStatusChecker(processId);
+                // Handled! Return the proper response too
+                if (process?.status === 'handled') {
+                    const result = await processCallbackResultFetcher(process.id, process.name, dto.processCallbackUrl);
+                    // Log and call runner
+                    console.warn(`Handled ${process.name} (${process.id})!`);
+                    options?.onSuccess?.(process.id, process.name, result);
+                    return {
+                        dto,
+                        metadata,
+                        options,
+                        success: true,
+                        pending: false,
+                        result,
+                    };
+                }
+                // Pending or failed
+                if (process?.status === 'pending') {
+                    console.log(`Running process ${process.name} (${process.id})...`);
+                    options?.onLoading?.(process.id, process.name);
+                    return { dto, metadata, options, pending: true };
+                }
+                else if (process?.status === 'failed') {
+                    console.error(`Failed ${process.name} (${process.id}) - ${process.error}.`);
+                    return {
+                        dto,
+                        metadata,
+                        options,
+                        success: false,
+                        pending: false,
+                        error: process.error,
+                    };
+                }
+                // Return null since no response
+                return { dto, metadata, options, pending: true };
+            },
+            // Returns the next interval length to use to wait for fetch
+            refetchInterval: (query) => {
+                const data = query.state.data;
+                if (data?.success !== undefined)
+                    return false;
+                // If not defined, init to 0
+                if (!clientProcessAttempts.current[processId])
+                    clientProcessAttempts.current[processId] = 0;
+                const interval = Math.min(500 * 2 ** clientProcessAttempts.current[processId], 10000);
+                clientProcessAttempts.current[processId] += 1;
+                return interval;
+            },
+        })),
+    });
+    /**
+     * Registers a new process to handle
+     *
+     * @param processId
+     * @param processCallbackDto
+     * @param options
+     */
+    const registerProcess = (processId, processCallbackDto, metadata, options) => {
+        setClientProcessDtos({
+            ...clientProcessDtos,
+            [processId]: { dto: processCallbackDto, metadata, options },
+        });
+    };
+    /**
+     * Retrieves a process
+     *
+     * @param processId
+     * @returns
+     */
+    const getProcess = (processId) => {
+        const clientProcess = clientProcesses.find((clientProcess) => clientProcess.data?.dto?.processId === processId)?.data ?? null;
+        return clientProcess ?? null;
+    };
+    /**
+     * Filters processes by the provided attribute.
+     *
+     * @param filterKey
+     */
+    const filterProcesses = (filterKey) => {
+        return clientProcesses
+            .filter((clientProcess) => !!clientProcess.data?.dto)
+            .map((clientProcess) => clientProcess.data)
+            .filter((clientProcessData) => clientProcessData?.metadata.filterKey === filterKey);
+    };
+    /**
+     * Refreshes the cache and invalidates all related processes.
+     */
+    const invalidateBasedOnResult = async (filter, invalidator) => {
+        await queryClient.invalidateQueries({
+            queryKey: ['.__process', filter],
+            exact: false,
+        });
+        const cachedClientProcesses = queryClient
+            .getQueryCache()
+            .findAll({ queryKey: ['.__process', filter], exact: false });
+        for (const query of cachedClientProcesses) {
+            const processId = query.queryKey[2];
+            if (typeof processId !== 'string')
+                continue;
+            const data = query.state.data;
+            if (!data.result)
+                continue;
+            // If invalidator says we gotta clear the cache, we clear it
+            if (invalidator && invalidator?.(data.result)) {
+                queryClient.removeQueries({ queryKey: query.queryKey });
+            }
+        }
+    };
+    return (jsx(clientProcessesContext.Provider, { value: {
+            registerProcess,
+            getProcess,
+            filterProcesses,
+            invalidateBasedOnResult,
+        }, children: children }));
+};
+/**
+ * A simpler version, where u just pass the async function that returns process data.
+ *
+ * @param caller
+ * @returns
+ */
+function useClientProcess({ caller, invalidator, filterKey, onLoading, onSuccess, onFailure, }) {
+    const clientProcessesApi = useContext(clientProcessesContext);
+    // Note that the exposed function doesn't return process ids
+    // Client should be oblivious to those
+    // Abstraction BABY!
+    const wrappedCaller = async (inputs, metadata) => {
+        const response = await caller?.(inputs);
+        if (response) {
+            clientProcessesApi.registerProcess(response.processId, response, { filterKey, metadata }, {
+                onLoading,
+                onSuccess,
+                onFailure,
+            });
+            return {
+                id: response.processId,
+                success: response.success,
+                message: response.message,
+            };
+        }
+        return {
+            id: null,
+            success: false,
+            message: 'No `caller` specified for useClientProcess().',
+        };
+    };
+    return {
+        run: wrappedCaller,
+        get: (id) => clientProcessesApi.getProcess(id),
+        getAll: () => clientProcessesApi.filterProcesses(filterKey),
+        getAllPending: () => clientProcessesApi
+            .filterProcesses(filterKey)
+            .filter((process) => process.pending),
+        getAllHandled: () => clientProcessesApi
+            .filterProcesses(filterKey)
+            .filter((process) => process.success),
+        getAllFailed: () => clientProcessesApi
+            .filterProcesses(filterKey)
+            .filter((process) => !process.success),
+        refreshCache: () => clientProcessesApi.invalidateBasedOnResult(filterKey, invalidator),
+    };
+}
+
+export { ClientProcessesProvider, useClientProcess };
+//# sourceMappingURL=useClientProcess.js.map

package/dist/hooks/useMQJob.d.ts

@@ -30,9 +30,9 @@ export declare const MQJobsProvider: ({ poll, children, }: MQJobsConfig & {
  * `status` is terminal.
  */
 export declare function useMQJob<T = unknown>(jobId?: string | null): {
-    job: MQJob<T> | undefined;
+    job: MQJob<unknown> | undefined;
     status: MQJobStatus | undefined;
-    result: T | undefined;
+    result: unknown;
     error: string | undefined;
     isPending: boolean;
     isDone: boolean;

package/dist/hooks/useMQJob.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMQJob.js","sources":["../../src/hooks/useMQJob.tsx"],"sourcesContent":["'use client';\n\nimport { createContext, useContext, useRef } from 'react';\nimport { useQueries, useQuery, Query } from '@tanstack/react-query';\n\nexport type MQJobStatus = 'queued' | 'processing' | 'done' | 'failed';\n\nexport interface MQJob<T = unknown> {\n  id: string;\n  type: string;\n  status: MQJobStatus;\n  progress?: { total: number; done: number; failed: number };\n  result?: T;\n  error?: string;\n}\n\ninterface MQJobsConfig {\n  /**\n   * Fetches the current state of a job. The package knows no URL and no\n   * response envelope — the consuming app owns both (plan §5.2). Reject/throw\n   * on a transport or not-found failure; React Query's own retry handles it.\n   */\n  poll: (jobId: string) => Promise<MQJob>;\n}\n\nconst MQJobsContext = createContext<MQJobsConfig | null>(null);\n\n/** Mount once near the root, alongside the app's other data providers. */\nexport const MQJobsProvider = ({\n  poll,\n  children,\n}: MQJobsConfig & { children: React.ReactNode }) => (\n  <MQJobsContext.Provider value={{ poll }}>{children}</MQJobsContext.Provider>\n);\n\nconst useMQJobsConfig = (caller: string): MQJobsConfig => {\n  const ctx = useContext(MQJobsContext);\n  if (!ctx)\n    throw new Error(`${caller}() must be used within a <MQJobsProvider>.`);\n  return ctx;\n};\n\nconst BASE_INTERVAL_MS = 2000;\nconst MAX_INTERVAL_MS = 10000;\n\n/** Capped backoff keyed per job id, so each job restarts its own count. */\nconst nextInterval = (\n  attempts: { current: Record<string, number> },\n  key: string,\n  status: MQJobStatus | undefined,\n): number | false => {\n  if (status === 'done' || status === 'failed') return false;\n  const attempt = attempts.current[key] ?? 0;\n  attempts.current[key] = attempt + 1;\n  return Math.min(BASE_INTERVAL_MS * 1.5 ** attempt, MAX_INTERVAL_MS);\n};\n\nconst summarize = <T,>(job: MQJob<T> | undefined) => ({\n  job,\n  status: job?.status,\n  result: job?.result,\n  error: job?.error,\n  isPending: !job || job.status === 'queued' || job.status === 'processing',\n  isDone: job?.status === 'done',\n  isFailed: job?.status === 'failed',\n});\n\n/**\n * Polls a single `internal.mq_jobs` row to completion. Replaces\n * `useClientProcess` for anything queued through the broker: no\n * callback-URL dance, the result comes back inline on the job itself once\n * `status` is terminal.\n */\nexport function useMQJob<T = unknown>(jobId?: string | null) {\n  const { poll } = useMQJobsConfig('useMQJob');\n  const attempts = useRef<Record<string, number>>({});\n\n  const query = useQuery<MQJob<T>>({\n    queryKey: ['.__mq_job', jobId],\n    // `poll`'s result field is caller-typed via `T`; the transport itself\n    // doesn't know or care what shape a given job's result has.\n    queryFn: () => poll(jobId as string) as Promise<MQJob<T>>,\n    enabled: !!jobId,\n    staleTime: Infinity,\n    refetchOnWindowFocus: true,\n    refetchIntervalInBackground: true,\n    refetchInterval: (query: Query<MQJob<T>>) =>\n      nextInterval(attempts, jobId ?? '', query.state.data?.status),\n  });\n\n  return summarize(query.data);\n}\n\n/**\n * Polls a dynamic set of `internal.mq_jobs` rows to completion — for a\n * feature that can have several jobs in flight at once (e.g. a list of\n * pending/handled items). Built on `useQueries` directly rather than\n * composing `useMQJob` in a loop, since the number of tracked ids changes\n * over time and that would violate the rules of hooks.\n */\nexport function useMQJobs<T = unknown>(jobIds: readonly string[]) {\n  const { poll } = useMQJobsConfig('useMQJobs');\n  const attempts = useRef<Record<string, number>>({});\n\n  const queries = useQueries({\n    queries: jobIds.map((jobId) => ({\n      queryKey: ['.__mq_job', jobId],\n      queryFn: () => poll(jobId) as Promise<MQJob<T>>,\n      staleTime: Infinity,\n      refetchOnWindowFocus: true,\n      refetchIntervalInBackground: true,\n      refetchInterval: (query: Query<MQJob<T>>) =>\n        nextInterval(attempts, jobId, query.state.data?.status),\n    })),\n  });\n\n  return jobIds.map((jobId, index) => ({\n    jobId,\n    ...summarize(queries[index]?.data as MQJob<T> | undefined),\n  }));\n}\n"],"names":[],"mappings":";;;;;AAyBA;AAEA;AACO;AAOP;AACE;AACA;AACE;AACF;AACF;AAEA;AACA;AAEA;AACA;AAKE;AAA8C;;;AAG9C;AACF;AAEA;;;;;AAKE;AACA;AACA;AACD;AAED;;;;;AAKG;AACG;;AAEJ;;AAGE;;;AAGA;;AAEA;AACA;AACA;;AAGD;AAED;AACF;AAEA;;;;;;AAMG;AACG;;AAEJ;;;AAII;AACA;AACA;AACA;AACA;AACA;AAED;AACF;;;;AAKA;AACH;;"}
+{"version":3,"file":"useMQJob.js","sources":["../../src/hooks/useMQJob.tsx"],"sourcesContent":["'use client';\r\n\r\nimport { createContext, useContext, useRef } from 'react';\r\nimport { useQueries, useQuery, Query } from '@tanstack/react-query';\r\n\r\nexport type MQJobStatus = 'queued' | 'processing' | 'done' | 'failed';\r\n\r\nexport interface MQJob<T = unknown> {\r\n  id: string;\r\n  type: string;\r\n  status: MQJobStatus;\r\n  progress?: { total: number; done: number; failed: number };\r\n  result?: T;\r\n  error?: string;\r\n}\r\n\r\ninterface MQJobsConfig {\r\n  /**\r\n   * Fetches the current state of a job. The package knows no URL and no\r\n   * response envelope — the consuming app owns both (plan §5.2). Reject/throw\r\n   * on a transport or not-found failure; React Query's own retry handles it.\r\n   */\r\n  poll: (jobId: string) => Promise<MQJob>;\r\n}\r\n\r\nconst MQJobsContext = createContext<MQJobsConfig | null>(null);\r\n\r\n/** Mount once near the root, alongside the app's other data providers. */\r\nexport const MQJobsProvider = ({\r\n  poll,\r\n  children,\r\n}: MQJobsConfig & { children: React.ReactNode }) => (\r\n  <MQJobsContext.Provider value={{ poll }}>{children}</MQJobsContext.Provider>\r\n);\r\n\r\nconst useMQJobsConfig = (caller: string): MQJobsConfig => {\r\n  const ctx = useContext(MQJobsContext);\r\n  if (!ctx)\r\n    throw new Error(`${caller}() must be used within a <MQJobsProvider>.`);\r\n  return ctx;\r\n};\r\n\r\nconst BASE_INTERVAL_MS = 2000;\r\nconst MAX_INTERVAL_MS = 10000;\r\n\r\n/** Capped backoff keyed per job id, so each job restarts its own count. */\r\nconst nextInterval = (\r\n  attempts: { current: Record<string, number> },\r\n  key: string,\r\n  status: MQJobStatus | undefined,\r\n): number | false => {\r\n  if (status === 'done' || status === 'failed') return false;\r\n  const attempt = attempts.current[key] ?? 0;\r\n  attempts.current[key] = attempt + 1;\r\n  return Math.min(BASE_INTERVAL_MS * 1.5 ** attempt, MAX_INTERVAL_MS);\r\n};\r\n\r\nconst summarize = <T,>(job: MQJob<T> | undefined) => ({\r\n  job,\r\n  status: job?.status,\r\n  result: job?.result,\r\n  error: job?.error,\r\n  isPending: !job || job.status === 'queued' || job.status === 'processing',\r\n  isDone: job?.status === 'done',\r\n  isFailed: job?.status === 'failed',\r\n});\r\n\r\n/**\r\n * Polls a single `internal.mq_jobs` row to completion. Replaces\r\n * `useClientProcess` for anything queued through the broker: no\r\n * callback-URL dance, the result comes back inline on the job itself once\r\n * `status` is terminal.\r\n */\r\nexport function useMQJob<T = unknown>(jobId?: string | null) {\r\n  const { poll } = useMQJobsConfig('useMQJob');\r\n  const attempts = useRef<Record<string, number>>({});\r\n\r\n  const query = useQuery<MQJob<T>>({\r\n    queryKey: ['.__mq_job', jobId],\r\n    // `poll`'s result field is caller-typed via `T`; the transport itself\r\n    // doesn't know or care what shape a given job's result has.\r\n    queryFn: () => poll(jobId as string) as Promise<MQJob<T>>,\r\n    enabled: !!jobId,\r\n    staleTime: Infinity,\r\n    refetchOnWindowFocus: true,\r\n    refetchIntervalInBackground: true,\r\n    refetchInterval: (query: Query<MQJob<T>>) =>\r\n      nextInterval(attempts, jobId ?? '', query.state.data?.status),\r\n  });\r\n\r\n  return summarize(query.data);\r\n}\r\n\r\n/**\r\n * Polls a dynamic set of `internal.mq_jobs` rows to completion — for a\r\n * feature that can have several jobs in flight at once (e.g. a list of\r\n * pending/handled items). Built on `useQueries` directly rather than\r\n * composing `useMQJob` in a loop, since the number of tracked ids changes\r\n * over time and that would violate the rules of hooks.\r\n */\r\nexport function useMQJobs<T = unknown>(jobIds: readonly string[]) {\r\n  const { poll } = useMQJobsConfig('useMQJobs');\r\n  const attempts = useRef<Record<string, number>>({});\r\n\r\n  const queries = useQueries({\r\n    queries: jobIds.map((jobId) => ({\r\n      queryKey: ['.__mq_job', jobId],\r\n      queryFn: () => poll(jobId) as Promise<MQJob<T>>,\r\n      staleTime: Infinity,\r\n      refetchOnWindowFocus: true,\r\n      refetchIntervalInBackground: true,\r\n      refetchInterval: (query: Query<MQJob<T>>) =>\r\n        nextInterval(attempts, jobId, query.state.data?.status),\r\n    })),\r\n  });\r\n\r\n  return jobIds.map((jobId, index) => ({\r\n    jobId,\r\n    ...summarize(queries[index]?.data as MQJob<T> | undefined),\r\n  }));\r\n}\r\n"],"names":[],"mappings":";;;;;AAyBA;AAEA;AACO;AAOP;AACE;AACA;AACE;AACF;AACF;AAEA;AACA;AAEA;AACA;AAKE;AAA8C;;;AAG9C;AACF;AAEA;;;;;AAKE;AACA;AACA;AACD;AAED;;;;;AAKG;AACG;;AAEJ;;AAGE;;;AAGA;;AAEA;AACA;AACA;;AAGD;AAED;AACF;AAEA;;;;;;AAMG;AACG;;AAEJ;;;AAII;AACA;AACA;AACA;AACA;AACA;AAED;AACF;;;;AAKA;AACH;;"}

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["import { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}"],"names":[],"mappings":";;;AAGM,SAAU,EAAE,CAAC,GAAG,MAAoB,EAAA;AACxC,IAAA,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC9B;;;;"}
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["import { clsx, type ClassValue } from \"clsx\";\r\nimport { twMerge } from \"tailwind-merge\";\r\n\r\nexport function cn(...inputs: ClassValue[]) {\r\n  return twMerge(clsx(inputs));\r\n}"],"names":[],"mappings":";;;AAGM,SAAU,EAAE,CAAC,GAAG,MAAoB,EAAA;AACxC,IAAA,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC9B;;;;"}