@manta-eu/react 0.1.0

package/dist/hooks/useConversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversations.d.ts","sourceRoot":"","sources":["../../src/hooks/useConversations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAKrG,KAAK,uBAAuB,GAAG,sBAAsB,GAAG;IACtD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAUF,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B;;;;;;;;;;;;;;;;;;;;;EAqBrE"}

package/dist/hooks/useConversations.js

@@ -0,0 +1,26 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { useQuery } from "@tanstack/react-query";
+import { useChatManagerConnection } from "../providers/ChatManagerProvider.js";
+function conversationsQueryKey(scope, revision, input) {
+    return ["conversations", scope ?? null, revision ?? 0, input];
+}
+export function useConversations(options = {}) {
+    const { enabled = true, ...input } = options;
+    const { connectionState, listConversations, managerState } = useChatManagerConnection();
+    const scope = managerState?.scope;
+    const revision = managerState?.chatListRevision;
+    const query = useQuery({
+        queryKey: conversationsQueryKey(scope, revision, input),
+        queryFn: () => listConversations(input),
+        enabled: enabled && connectionState === "open" && isPresent(scope),
+        placeholderData: (previousData) => previousData,
+        gcTime: 0,
+        staleTime: Infinity,
+    });
+    return {
+        conversations: query.data ?? [],
+        isLoading: query.isPending,
+        error: query.error ?? undefined,
+        enabled,
+    };
+}

package/dist/hooks/useDatastoreSelection.d.ts

@@ -0,0 +1,9 @@
+export type SwitchTargetKind = "organization" | "datastore";
+export type UseDatastoreSelectionArgs = {
+    canSwitchDatastore?: boolean;
+};
+export declare function useDatastoreSelection(args?: UseDatastoreSelectionArgs): {
+    setSelectedDatastore: (datastoreId?: string, kind?: SwitchTargetKind) => Promise<boolean>;
+    isSwitching: boolean;
+};
+//# sourceMappingURL=useDatastoreSelection.d.ts.map

package/dist/hooks/useDatastoreSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDatastoreSelection.d.ts","sourceRoot":"","sources":["../../src/hooks/useDatastoreSelection.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,WAAW,CAAC;AAc5D,MAAM,MAAM,yBAAyB,GAAG;IACtC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAcF,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,yBAA8B;yCASjD,MAAM,SAAQ,gBAAgB,KAAiB,OAAO,CAAC,OAAO,CAAC;;EAwDvF"}

package/dist/hooks/useDatastoreSelection.js

@@ -0,0 +1,84 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useState } from "react";
+import { useLocation } from "react-router";
+import { toast } from "sonner";
+import { datastoreSwitchFallbackPath } from "../lib/datastore-route-paths.js";
+import { useActiveDatastore, useMantaClient } from "../providers/index.js";
+const switchDatastoreToastId = "switch-datastore";
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function isSwitchDatastoreResult(json) {
+    if (!isPresent(json))
+        return false;
+    const r = json;
+    return r.success === true && typeof r.valid === "boolean";
+}
+function extractApiError(json, fallback) {
+    if (typeof json === "object" &&
+        json !== null &&
+        "error" in json &&
+        typeof json.error === "string") {
+        return json.error;
+    }
+    return fallback;
+}
+export function useDatastoreSelection(args = {}) {
+    const { canSwitchDatastore = false } = args;
+    const { mantaBaseUrl } = useMantaClient();
+    const queryClient = useQueryClient();
+    const { datastoreId: activeDatastoreId, enterDatastore } = useActiveDatastore();
+    const { pathname, search, hash } = useLocation();
+    const [isSwitching, setIsSwitching] = useState(false);
+    const setSelectedDatastore = useCallback(async (datastoreId, kind = "datastore") => {
+        if (!canSwitchDatastore) {
+            toast.error(`${capitalize(kind)} switching is not supported.`);
+            return false;
+        }
+        if (!datastoreId) {
+            toast.error(`No ${kind} selected.`);
+            return false;
+        }
+        setIsSwitching(true);
+        toast.loading(`Switching ${kind}...`, { id: switchDatastoreToastId });
+        try {
+            const response = await fetch(new URL("/api/switch-datastore", mantaBaseUrl), {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ datastoreId }),
+                credentials: "include",
+            });
+            if (!response.ok) {
+                const json = await response.json().catch(() => undefined);
+                throw new Error(extractApiError(json, `Switch failed with status ${response.status}`));
+            }
+            const json = await response.json().catch(() => undefined);
+            if (!isSwitchDatastoreResult(json))
+                throw new Error("Unexpected switch-datastore response");
+            if (activeDatastoreId) {
+                const fallback = datastoreSwitchFallbackPath(pathname);
+                enterDatastore(datastoreId, { path: fallback ?? `${pathname}${search}${hash}`, replace: true });
+            }
+            else {
+                // Entering rotates the QueryClient; on the global tree nothing rotates, so the cache has to go.
+                await queryClient.invalidateQueries();
+            }
+            toast.success(`${capitalize(kind)} switched successfully.`, { id: switchDatastoreToastId });
+            return true;
+        }
+        catch (error) {
+            toast.error(`Failed to switch ${kind}: ${error instanceof Error ? error.message : "Unknown error"}`, {
+                id: switchDatastoreToastId,
+            });
+            return false;
+        }
+        finally {
+            setIsSwitching(false);
+        }
+    }, [activeDatastoreId, canSwitchDatastore, enterDatastore, hash, mantaBaseUrl, pathname, queryClient, search]);
+    return {
+        setSelectedDatastore,
+        isSwitching,
+    };
+}

package/dist/hooks/useDeleteChat.d.ts

@@ -0,0 +1,8 @@
+import { type MouseEvent } from "react";
+export declare function useDeleteChat(): {
+    handleDeleteClick: (conversationId: string, event: MouseEvent) => void;
+    handleConfirmDelete: () => Promise<void>;
+    handleCancelDelete: () => void;
+    conversationToDelete: string | null;
+};
+//# sourceMappingURL=useDeleteChat.d.ts.map

package/dist/hooks/useDeleteChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeleteChat.d.ts","sourceRoot":"","sources":["../../src/hooks/useDeleteChat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,UAAU,EAAE,MAAM,OAAO,CAAC;AAIlD,wBAAgB,aAAa;wCAIgB,MAAM,SAAS,UAAU,KAAG,IAAI;+BAKrC,OAAO,CAAC,IAAI,CAAC;8BAiBpB,IAAI;;EAUpC"}

package/dist/hooks/useDeleteChat.js

@@ -0,0 +1,39 @@
+import { useState } from "react";
+import { toast } from "sonner";
+import { useChatManagerConnection } from "../providers/ChatManagerProvider.js";
+export function useDeleteChat() {
+    const { deleteConversation } = useChatManagerConnection();
+    const [conversationToDelete, setConversationToDelete] = useState(null);
+    function handleDeleteClick(conversationId, event) {
+        event.stopPropagation();
+        setConversationToDelete(conversationId);
+    }
+    async function handleConfirmDelete() {
+        if (!conversationToDelete)
+            return;
+        try {
+            const result = await deleteConversation(conversationToDelete);
+            if (result.status === "deleted") {
+                toast.success("Conversation deleted successfully");
+            }
+            else {
+                toast.error("Conversation not found");
+            }
+        }
+        catch (error) {
+            toast.error(`Error deleting conversation: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            setConversationToDelete(null);
+        }
+    }
+    function handleCancelDelete() {
+        setConversationToDelete(null);
+    }
+    return {
+        handleDeleteClick,
+        handleConfirmDelete,
+        handleCancelDelete,
+        conversationToDelete,
+    };
+}

package/dist/hooks/useExecuteAction.d.ts

@@ -0,0 +1,19 @@
+import { GQLExecuteActionErrorCode } from "@manta-eu/client";
+import { type ExecuteActionTarget } from "#lib/action-document";
+export type ExecuteActionResult = {
+    success: true;
+    workflowId: string;
+    namedGraphIri: string;
+} | {
+    success: false;
+    error: string;
+    code: GQLExecuteActionErrorCode;
+};
+export type UseExecuteActionResult = {
+    isPending: boolean;
+    addition: (properties: Record<string, unknown>) => Promise<ExecuteActionResult>;
+    update: (properties: Record<string, unknown>) => Promise<ExecuteActionResult>;
+    deletion: () => Promise<ExecuteActionResult>;
+};
+export declare function useExecuteAction({ subjectIri, rdfType, actionShape }: ExecuteActionTarget): UseExecuteActionResult;
+//# sourceMappingURL=useExecuteAction.d.ts.map

package/dist/hooks/useExecuteAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecuteAction.d.ts","sourceRoot":"","sources":["../../src/hooks/useExecuteAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EAI1B,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAA4C,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAI1G,MAAM,MAAM,mBAAmB,GAC3B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAA;CAAE,CAAC;AAEvE,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAChF,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC9E,QAAQ,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC9C,CAAC;AAsBF,wBAAgB,gBAAgB,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,mBAAmB,GAAG,sBAAsB,CA4FlH"}

package/dist/hooks/useExecuteAction.js

@@ -0,0 +1,82 @@
+import { GQLExecuteActionErrorCode, useExecuteAgentActionAdditionMutation, useExecuteAgentActionDeletionMutation, useExecuteAgentActionUpdateMutation, } from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useRef } from "react";
+import { actionDocumentIssue, buildActionDocument } from "#lib/action-document";
+import { useMantaClient } from "#providers/MantaClientProvider";
+import { invalidateActionPlanQueries } from "#shared/query-keys";
+function toResult(response) {
+    if (response.success && isPresent(response.workflowId) && isPresent(response.namedGraphIri)) {
+        return { success: true, workflowId: response.workflowId, namedGraphIri: response.namedGraphIri };
+    }
+    return {
+        success: false,
+        error: response.error ?? "Failed to start the action",
+        code: response.code ?? GQLExecuteActionErrorCode.Unknown,
+    };
+}
+export function useExecuteAction({ subjectIri, rdfType, actionShape }) {
+    const inFlight = useRef(false);
+    const { mantaClient } = useMantaClient();
+    const queryClient = useQueryClient();
+    const { mutateAsync: startAddition, isPending: additionPending } = useExecuteAgentActionAdditionMutation(mantaClient);
+    const { mutateAsync: startUpdate, isPending: updatePending } = useExecuteAgentActionUpdateMutation(mantaClient);
+    const { mutateAsync: startDeletion, isPending: deletionPending } = useExecuteAgentActionDeletionMutation(mantaClient);
+    const run = useCallback(async (start) => {
+        if (inFlight.current) {
+            return {
+                success: false,
+                error: "An action is already running on this record.",
+                code: GQLExecuteActionErrorCode.Conflict,
+            };
+        }
+        inFlight.current = true;
+        try {
+            const outcome = toResult(await start());
+            if (outcome.success)
+                void invalidateActionPlanQueries(queryClient, outcome.namedGraphIri);
+            return outcome;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to start the action";
+            return { success: false, error: message, code: GQLExecuteActionErrorCode.Unknown };
+        }
+        finally {
+            inFlight.current = false;
+        }
+    }, [queryClient]);
+    const runWithDocument = useCallback((properties, start) => {
+        const document = buildActionDocument({ subjectIri, rdfType }, properties);
+        const issue = actionDocumentIssue(document);
+        if (issue) {
+            return Promise.resolve({
+                success: false,
+                error: issue,
+                code: GQLExecuteActionErrorCode.BadRequest,
+            });
+        }
+        return run(() => start(document));
+    }, [run, subjectIri, rdfType]);
+    const addition = useCallback((properties) => runWithDocument(properties, async (document) => {
+        const response = await startAddition({
+            input: { subjectIri, rdfType, actionShape, properties: document },
+        });
+        return response.executeActionAddition;
+    }), [runWithDocument, startAddition, subjectIri, rdfType, actionShape]);
+    const update = useCallback((properties) => runWithDocument(properties, async (document) => {
+        const response = await startUpdate({
+            input: { subjectIri, rdfType, actionShape, properties: document },
+        });
+        return response.executeActionUpdate;
+    }), [runWithDocument, startUpdate, subjectIri, rdfType, actionShape]);
+    const deletion = useCallback(() => run(async () => {
+        const response = await startDeletion({ input: { subjectIri, rdfType, actionShape } });
+        return response.executeActionDeletion;
+    }), [run, startDeletion, subjectIri, rdfType, actionShape]);
+    return {
+        isPending: additionPending || updatePending || deletionPending,
+        addition,
+        update,
+        deletion,
+    };
+}

package/dist/hooks/useFittedPagination.d.ts

@@ -0,0 +1,36 @@
+import { type RefCallback } from "react";
+export declare const minFittedPageSize = 5;
+export declare const maxFittedPageSize = 50;
+export type FittedPageSizeOptions = {
+    headerRowHeight?: number;
+    rowHeight?: number;
+    reservedHeight?: number;
+    minPageSize?: number;
+    maxPageSize?: number;
+};
+export type ComputeFittedPageSizeArgs = FittedPageSizeOptions & {
+    availableHeight: number;
+};
+export type ComputeResizedPageIndexArgs = {
+    pageIndex: number;
+    previousPageSize: number;
+    pageSize: number;
+};
+export type ShouldClampPageIndexArgs = {
+    isLoading?: boolean;
+    pageIndex: number;
+    totalPages: number;
+};
+export type FittedPaginationOptions = FittedPageSizeOptions & {
+    pageIndex: number;
+    onPageIndexChange: (pageIndex: number) => void;
+};
+export declare function computeFittedPageSize(args: ComputeFittedPageSizeArgs): number;
+export declare function computeResizedPageIndex(args: ComputeResizedPageIndexArgs): number;
+export declare function shouldClampPageIndex(args: ShouldClampPageIndexArgs): boolean;
+export declare function useFittedPagination<T extends HTMLElement>(options: FittedPaginationOptions): {
+    containerRef: RefCallback<T>;
+    isMeasured: boolean;
+    pageSize: number;
+};
+//# sourceMappingURL=useFittedPagination.d.ts.map

package/dist/hooks/useFittedPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFittedPagination.d.ts","sourceRoot":"","sources":["../../src/hooks/useFittedPagination.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AAEnF,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAMpC,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,qBAAqB,GAAG;IAC9D,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,qBAAqB,GAAG;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,yBAAyB,GAAG,MAAM,CAW7E;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,2BAA2B,GAAG,MAAM,CAEjF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,wBAAwB,GAAG,OAAO,CAI5E;AAED,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,WAAW,EACvD,OAAO,EAAE,uBAAuB,GAC/B;IACD,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB,CA4DA"}

package/dist/hooks/useFittedPagination.js

@@ -0,0 +1,62 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+export const minFittedPageSize = 5;
+export const maxFittedPageSize = 50;
+const defaultHeaderRowHeight = 45;
+const defaultRowHeight = 53;
+const defaultReservedHeight = 72;
+export function computeFittedPageSize(args) {
+    const { availableHeight, headerRowHeight = defaultHeaderRowHeight, rowHeight = defaultRowHeight, reservedHeight = defaultReservedHeight, minPageSize = minFittedPageSize, maxPageSize = maxFittedPageSize, } = args;
+    const rows = Math.floor((availableHeight - headerRowHeight - reservedHeight) / rowHeight);
+    return Math.min(maxPageSize, Math.max(minPageSize, rows));
+}
+export function computeResizedPageIndex(args) {
+    return Math.floor((args.pageIndex * args.previousPageSize) / args.pageSize);
+}
+export function shouldClampPageIndex(args) {
+    const { isLoading, pageIndex, totalPages } = args;
+    return !isLoading && pageIndex > totalPages - 1;
+}
+export function useFittedPagination(options) {
+    const { pageIndex, onPageIndexChange, headerRowHeight = defaultHeaderRowHeight, rowHeight = defaultRowHeight, reservedHeight = defaultReservedHeight, minPageSize = minFittedPageSize, maxPageSize = maxFittedPageSize, } = options;
+    const previousPageSizeRef = useRef(null);
+    const [measuredPageSize, setMeasuredPageSize] = useState(null);
+    const containerRef = useCallback((element) => {
+        if (!element)
+            return;
+        const container = element;
+        function applyHeight() {
+            setMeasuredPageSize(computeFittedPageSize({
+                availableHeight: container.getBoundingClientRect().height,
+                headerRowHeight,
+                rowHeight,
+                reservedHeight,
+                minPageSize,
+                maxPageSize,
+            }));
+        }
+        applyHeight();
+        const observer = new ResizeObserver(applyHeight);
+        observer.observe(container);
+        return () => observer.disconnect();
+    }, [headerRowHeight, maxPageSize, minPageSize, reservedHeight, rowHeight]);
+    useEffect(() => {
+        if (measuredPageSize === null)
+            return;
+        const previousPageSize = previousPageSizeRef.current;
+        previousPageSizeRef.current = measuredPageSize;
+        if (previousPageSize === null || previousPageSize === measuredPageSize)
+            return;
+        const nextPageIndex = computeResizedPageIndex({
+            pageIndex,
+            previousPageSize,
+            pageSize: measuredPageSize,
+        });
+        if (nextPageIndex !== pageIndex)
+            onPageIndexChange(nextPageIndex);
+    }, [measuredPageSize, onPageIndexChange, pageIndex]);
+    return {
+        containerRef,
+        isMeasured: measuredPageSize !== null,
+        pageSize: measuredPageSize ?? minPageSize,
+    };
+}

package/dist/hooks/useOnboardingState.d.ts

@@ -0,0 +1,8 @@
+type OnboardingState = {
+    shouldShow: boolean;
+    complete: () => void;
+    dismiss: () => void;
+};
+export declare function useOnboardingState(): OnboardingState;
+export {};
+//# sourceMappingURL=useOnboardingState.d.ts.map

package/dist/hooks/useOnboardingState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnboardingState.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnboardingState.ts"],"names":[],"mappings":"AAMA,KAAK,eAAe,GAAG;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,wBAAgB,kBAAkB,IAAI,eAAe,CAcpD"}

package/dist/hooks/useOnboardingState.js

@@ -0,0 +1,16 @@
+import Cookies from "js-cookie";
+import { useCallback, useState } from "react";
+const onboardingCookieName = "manta-onboarding-completed";
+const onboardingCookieExpiryDays = 365;
+export function useOnboardingState() {
+    const [hasCompleted, setHasCompleted] = useState(() => Cookies.get(onboardingCookieName) === "1");
+    const [dismissedThisSession, setDismissedThisSession] = useState(false);
+    const complete = useCallback(() => {
+        Cookies.set(onboardingCookieName, "1", { expires: onboardingCookieExpiryDays, sameSite: "lax", secure: true });
+        setHasCompleted(true);
+    }, []);
+    const dismiss = useCallback(() => {
+        setDismissedThisSession(true);
+    }, []);
+    return { shouldShow: !hasCompleted && !dismissedThisSession, complete, dismiss };
+}

package/dist/hooks/useRerunPlan.d.ts

@@ -0,0 +1,7 @@
+export declare function useRerunPlan(): {
+    handleRerunClick: (planIri: string) => void;
+    handleConfirmRerun: (dryRun?: boolean) => Promise<void>;
+    handleCancelRerun: () => void;
+    planToRerun: string | undefined;
+};
+//# sourceMappingURL=useRerunPlan.d.ts.map

package/dist/hooks/useRerunPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRerunPlan.d.ts","sourceRoot":"","sources":["../../src/hooks/useRerunPlan.ts"],"names":[],"mappings":"AAOA,wBAAgB,YAAY;gCAOS,MAAM,KAAG,IAAI;8CAIG,OAAO,CAAC,IAAI,CAAC;6BAyBlC,IAAI;;EAUnC"}

package/dist/hooks/useRerunPlan.js

@@ -0,0 +1,44 @@
+import { useExecuteAgentActionPlanMutation } from "@manta-eu/client";
+import { useQueryClient } from "@tanstack/react-query";
+import { useState } from "react";
+import { toast } from "sonner";
+import { useMantaClient } from "../providers/index.js";
+import { invalidateActionPlanQueries } from "../shared/query-keys.js";
+export function useRerunPlan() {
+    const { mantaClient } = useMantaClient();
+    const queryClient = useQueryClient();
+    const [planToRerun, setPlanToRerun] = useState();
+    const rerunMutation = useExecuteAgentActionPlanMutation(mantaClient);
+    function handleRerunClick(planIri) {
+        setPlanToRerun(planIri);
+    }
+    async function handleConfirmRerun(dryRun = false) {
+        if (!planToRerun)
+            return;
+        const planIri = planToRerun;
+        setPlanToRerun(undefined);
+        await rerunMutation.mutateAsync({ input: { namedGraphIri: planIri, shaclShapeIri: planIri, dryRun } }, {
+            onSuccess: (data) => {
+                if (data.executeActionPlan.success) {
+                    toast.success(dryRun ? "Plan re-run preview triggered" : "Plan re-run triggered");
+                    void invalidateActionPlanQueries(queryClient, planIri);
+                }
+                else {
+                    toast.error(data.executeActionPlan.error || (dryRun ? "Failed to preview plan re-run" : "Failed to re-run plan"));
+                }
+            },
+            onError: (error) => {
+                toast.error(`Error re-running plan: ${error instanceof Error ? error.message : String(error)}`);
+            },
+        });
+    }
+    function handleCancelRerun() {
+        setPlanToRerun(undefined);
+    }
+    return {
+        handleRerunClick,
+        handleConfirmRerun,
+        handleCancelRerun,
+        planToRerun,
+    };
+}

package/dist/hooks/useResizablePanel.d.ts

@@ -0,0 +1,2 @@
+export { clampPanelWidth, useResizablePanel } from "#lib/use-resizable-panel";
+//# sourceMappingURL=useResizablePanel.d.ts.map

package/dist/hooks/useResizablePanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResizablePanel.d.ts","sourceRoot":"","sources":["../../src/hooks/useResizablePanel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/hooks/useResizablePanel.js

@@ -0,0 +1 @@
+export { clampPanelWidth, useResizablePanel } from "#lib/use-resizable-panel";

package/dist/hooks/useSelectedModel.d.ts

@@ -0,0 +1,4 @@
+import type { OperatorAllowedModel } from "@manta-eu/client/shared/model";
+export declare const selectedModelStorageKey = "manta-selected-model";
+export declare function useSelectedModel(defaultModel: OperatorAllowedModel): [OperatorAllowedModel, (next: OperatorAllowedModel) => void];
+//# sourceMappingURL=useSelectedModel.d.ts.map

package/dist/hooks/useSelectedModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelectedModel.d.ts","sourceRoot":"","sources":["../../src/hooks/useSelectedModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAK1E,eAAO,MAAM,uBAAuB,yBAAyB,CAAC;AAE9D,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,oBAAoB,GACjC,CAAC,oBAAoB,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC,CAO9D"}

package/dist/hooks/useSelectedModel.js

@@ -0,0 +1,10 @@
+import { isOperatorAllowedModel } from "@manta-eu/client/shared/model";
+import { useCallback } from "react";
+import { useLocalStorage } from "usehooks-ts";
+export const selectedModelStorageKey = "manta-selected-model";
+export function useSelectedModel(defaultModel) {
+    const [stored, setStored] = useLocalStorage(selectedModelStorageKey, defaultModel);
+    const model = isOperatorAllowedModel(stored) ? stored : defaultModel;
+    const setModel = useCallback((next) => setStored(next), [setStored]);
+    return [model, setModel];
+}

package/dist/hooks/useTabParam.d.ts

@@ -0,0 +1,4 @@
+export declare function useTabParam<Value extends string>(tabs: readonly {
+    value: Value;
+}[], defaultValue: Value): readonly [Value extends undefined ? Value | null : Value, (next: string) => void];
+//# sourceMappingURL=useTabParam.d.ts.map

package/dist/hooks/useTabParam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTabParam.d.ts","sourceRoot":"","sources":["../../src/hooks/useTabParam.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,EAAE,SAAS;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,EAAE,EAAE,YAAY,EAAE,KAAK,oEAQ7E,MAAM,WAOhC"}

package/dist/hooks/useTabParam.js

@@ -0,0 +1,11 @@
+import { parseAsStringLiteral, useQueryState } from "nuqs";
+export function useTabParam(tabs, defaultValue) {
+    const values = tabs.map((tab) => tab.value);
+    const [tab, setTab] = useQueryState("tab", parseAsStringLiteral(values).withDefault(defaultValue).withOptions({ history: "push" }));
+    function selectTab(next) {
+        const selected = values.find((value) => value === next);
+        if (selected)
+            void setTab(selected);
+    }
+    return [tab, selectTab];
+}

package/dist/hooks/useUserMessageScroller.d.ts

@@ -0,0 +1,8 @@
+import type { ChatStatus } from "ai";
+import type { RefObject } from "react";
+export type ScrollableMessage = {
+    id: string;
+    role: string;
+};
+export declare function useUserMessageScroller(messages: ScrollableMessage[], status?: ChatStatus, activeTurnKey?: string): RefObject<HTMLDivElement | null>;
+//# sourceMappingURL=useUserMessageScroller.d.ts.map

package/dist/hooks/useUserMessageScroller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUserMessageScroller.d.ts","sourceRoot":"","sources":["../../src/hooks/useUserMessageScroller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAErC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAkHvC,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,MAAM,CAAC,EAAE,UAAU,EACnB,aAAa,CAAC,EAAE,MAAM,GACrB,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAgOlC"}