@everysk/apps-sdk 0.1.0-beta.0

package/dist/hooks/workflow/useRunWorkflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRunWorkflow.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useRunWorkflow.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAGnE,KAAK,gBAAgB,GAAG;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,SAAS,CAAC;IACtB,WAAW,CAAC,EAAE,4BAA4B,CAAC;CAC9C,CAAC;AAKF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc;;;CA2B1B,CAAC"}

package/dist/hooks/workflow/useRunWorkflow.js

@@ -0,0 +1,50 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.js";
+import { runWorkflow, runWorkflowAndGetResult } from "../../api/workflow.js";
+import { useMutation } from "@tanstack/react-query";
+//#region src/hooks/workflow/useRunWorkflow.ts
+var getErrorMessage = (err, fallback) => err instanceof Error && err.message ? err.message : fallback;
+/**
+* useRunWorkflow
+*
+* TanStack Query mutations to run a workflow. Synchronous execution (`synchronous: true`) is
+* intentionally not used; instead the workflow is started asynchronously and, when the result
+* is needed, its execution is polled until it reaches a terminal state.
+*
+* - `runAsync`: starts the workflow and returns immediately (fire-and-forget). Use when you do
+*   not need to wait for completion or consume the output.
+* - `runAndGetResult`: starts the workflow, polls until it finishes, then fetches the output of
+*   the ender worker. Resolves with `{ execution, workerExecution, result }`; `result` is `null`
+*   when the workflow produces no output. This is the replacement for the old synchronous flow.
+*
+* Both surface the standard mutation helpers (`mutate`, `mutateAsync`, `isPending`, `data`, ...)
+* and report failures through `useAppAlert`.
+*/
+var useRunWorkflow = () => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	return {
+		runAsync: useMutation({
+			mutationFn: ({ id, workspace, parameters }) => runWorkflow(api, id, workspace, parameters),
+			onError: (err) => {
+				showAlert({
+					severity: "error",
+					message: getErrorMessage(err, "Unable to run the workflow. Please try again.")
+				});
+			}
+		}),
+		runAndGetResult: useMutation({
+			mutationFn: ({ id, workspace, parameters, pollOptions }) => runWorkflowAndGetResult(api, id, workspace, parameters, pollOptions),
+			onError: (err) => {
+				showAlert({
+					severity: "error",
+					message: getErrorMessage(err, "Unable to run the workflow. Please try again.")
+				});
+			}
+		})
+	};
+};
+//#endregion
+export { useRunWorkflow };
+
+//# sourceMappingURL=useRunWorkflow.js.map

package/dist/hooks/workflow/useRunWorkflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRunWorkflow.js","names":[],"sources":["../../../src/hooks/workflow/useRunWorkflow.ts"],"sourcesContent":["import { useMutation } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport type { AnyRecord } from \"@/types/anyRecord\";\nimport type { PollWorkflowExecutionOptions } from \"@/api/workflow\";\nimport { runWorkflow, runWorkflowAndGetResult } from \"@/api/workflow\";\n\ntype RunWorkflowProps = {\n    id: string;\n    workspace: string;\n    parameters: AnyRecord;\n    pollOptions?: PollWorkflowExecutionOptions;\n};\n\nconst getErrorMessage = (err: unknown, fallback: string) =>\n    err instanceof Error && err.message ? err.message : fallback;\n\n/**\n * useRunWorkflow\n *\n * TanStack Query mutations to run a workflow. Synchronous execution (`synchronous: true`) is\n * intentionally not used; instead the workflow is started asynchronously and, when the result\n * is needed, its execution is polled until it reaches a terminal state.\n *\n * - `runAsync`: starts the workflow and returns immediately (fire-and-forget). Use when you do\n *   not need to wait for completion or consume the output.\n * - `runAndGetResult`: starts the workflow, polls until it finishes, then fetches the output of\n *   the ender worker. Resolves with `{ execution, workerExecution, result }`; `result` is `null`\n *   when the workflow produces no output. This is the replacement for the old synchronous flow.\n *\n * Both surface the standard mutation helpers (`mutate`, `mutateAsync`, `isPending`, `data`, ...)\n * and report failures through `useAppAlert`.\n */\nexport const useRunWorkflow = () => {\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const runAsync = useMutation({\n        mutationFn: ({ id, workspace, parameters }: RunWorkflowProps) =>\n            runWorkflow(api, id, workspace, parameters),\n        onError: (err) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(err, \"Unable to run the workflow. Please try again.\"),\n            });\n        },\n    });\n\n    const runAndGetResult = useMutation({\n        mutationFn: ({ id, workspace, parameters, pollOptions }: RunWorkflowProps) =>\n            runWorkflowAndGetResult(api, id, workspace, parameters, pollOptions),\n        onError: (err) => {\n            showAlert({\n                severity: \"error\",\n                message: getErrorMessage(err, \"Unable to run the workflow. Please try again.\"),\n            });\n        },\n    });\n\n    return { runAsync, runAndGetResult };\n};\n"],"mappings":";;;;;AAeA,IAAM,mBAAmB,KAAc,aACnC,eAAe,SAAS,IAAI,UAAU,IAAI,UAAU;;;;;;;;;;;;;;;;;AAkBxD,IAAa,uBAAuB;CAChC,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAwBlC,OAAO;EAAE,UAtBQ,YAAY;GACzB,aAAa,EAAE,IAAI,WAAW,iBAC1B,YAAY,KAAK,IAAI,WAAW,UAAU;GAC9C,UAAU,QAAQ;IACd,UAAU;KACN,UAAU;KACV,SAAS,gBAAgB,KAAK,+CAA+C;IACjF,CAAC;GACL;EACJ,CAaS;EAAU,iBAXK,YAAY;GAChC,aAAa,EAAE,IAAI,WAAW,YAAY,kBACtC,wBAAwB,KAAK,IAAI,WAAW,YAAY,WAAW;GACvE,UAAU,QAAQ;IACd,UAAU;KACN,UAAU;KACV,SAAS,gBAAgB,KAAK,+CAA+C;IACjF,CAAC;GACL;EACJ,CAEmB;CAAgB;AACvC"}

package/dist/hooks/workspace/useFetchWorkspace.d.ts

@@ -0,0 +1,197 @@
+import type { Workspace } from "../../types/workspace.d.ts";
+import type { EntityQueryOptions } from "../../types/entityQuery.d.ts";
+export type FetchWorkspaceProps<TData = Workspace, TSelected = TData> = {
+    name: string;
+    queryOptions?: EntityQueryOptions<TData, TSelected>;
+};
+/**
+ * useFetchWorkspace
+ *
+ * Data-fetching hook built on TanStack Query to retrieve a single workspace by name.
+ *
+ * It also:
+ * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+ * - triggers an error alert via `useAppAlert` whenever `query.error` is present
+ *
+ * Parameters (FetchWorkspaceProps):
+ * @param {string} name
+ *   Workspace name (required).
+ *
+ * @param queryOptions
+ *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * Returns:
+ * @returns {object}
+ *   TanStack Query's `query` object extended with:
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * Example:
+ * ```ts
+ * const { data, isLoading } = useFetchWorkspace({ name: "main" });
+ * // data -> Workspace
+ * ```
+ */
+export declare const useFetchWorkspace: ({ name, queryOptions }: FetchWorkspaceProps) => {
+    queryKey: string[];
+    data: Workspace;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workspace, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: Workspace;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workspace, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workspace, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workspace, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workspace, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: Workspace;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Workspace, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+};
+//# sourceMappingURL=useFetchWorkspace.d.ts.map

package/dist/hooks/workspace/useFetchWorkspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkspace.d.ts","sourceRoot":"","sources":["../../../src/hooks/workspace/useFetchWorkspace.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,mBAAmB,CAAC,KAAK,GAAG,SAAS,EAAE,SAAS,GAAG,KAAK,IAAI;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;CACvD,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAAI,wBAA8C,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlG,CAAC"}

package/dist/hooks/workspace/useFetchWorkspace.js

@@ -0,0 +1,65 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.js";
+import { getWorkspace } from "../../api/workspace.js";
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+//#region src/hooks/workspace/useFetchWorkspace.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkspace
+*
+* Data-fetching hook built on TanStack Query to retrieve a single workspace by name.
+*
+* It also:
+* - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+* - triggers an error alert via `useAppAlert` whenever `query.error` is present
+*
+* Parameters (FetchWorkspaceProps):
+* @param {string} name
+*   Workspace name (required).
+*
+* @param queryOptions
+*   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+*
+* Returns:
+* @returns {object}
+*   TanStack Query's `query` object extended with:
+*   - `queryKey`: the cache key used by React Query
+*
+* Example:
+* ```ts
+* const { data, isLoading } = useFetchWorkspace({ name: "main" });
+* // data -> Workspace
+* ```
+*/
+var useFetchWorkspace = ({ name, queryOptions = defaultQueryOptions }) => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	const queryKey = ["workspace", name];
+	const query = useQuery({
+		queryKey,
+		queryFn: async () => {
+			return await getWorkspace(api, name);
+		},
+		...queryOptions ?? {}
+	});
+	useEffect(() => {
+		if (!query.error) return;
+		showAlert({
+			severity: "error",
+			message: query.error.message
+		});
+	}, [query.error, showAlert]);
+	return {
+		...query,
+		queryKey
+	};
+};
+//#endregion
+export { useFetchWorkspace };
+
+//# sourceMappingURL=useFetchWorkspace.js.map

package/dist/hooks/workspace/useFetchWorkspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkspace.js","names":[],"sources":["../../../src/hooks/workspace/useFetchWorkspace.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport type { Workspace } from \"@/types/workspace\";\nimport { getWorkspace } from \"@/api/workspace\";\nimport type { EntityQueryOptions } from \"@/types/entityQuery\";\n\nexport type FetchWorkspaceProps<TData = Workspace, TSelected = TData> = {\n    name: string;\n    queryOptions?: EntityQueryOptions<TData, TSelected>;\n};\n\nconst defaultQueryOptions: EntityQueryOptions<Workspace> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkspace\n *\n * Data-fetching hook built on TanStack Query to retrieve a single workspace by name.\n *\n * It also:\n * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * Parameters (FetchWorkspaceProps):\n * @param {string} name\n *   Workspace name (required).\n *\n * @param queryOptions\n *   TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *\n * Returns:\n * @returns {object}\n *   TanStack Query's `query` object extended with:\n *   - `queryKey`: the cache key used by React Query\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchWorkspace({ name: \"main\" });\n * // data -> Workspace\n * ```\n */\nexport const useFetchWorkspace = ({ name, queryOptions = defaultQueryOptions }: FetchWorkspaceProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"workspace\", name];\n\n    const query = useQuery<Workspace>({\n        queryKey,\n        queryFn: async () => {\n            const workspace = await getWorkspace(api, name);\n            return workspace;\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;AAeA,IAAM,sBAAqD;CACvD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,qBAAqB,EAAE,MAAM,eAAe,0BAA+C;CAEpG,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW,CAAC,aAAa,IAAI;CAEnC,MAAM,QAAQ,SAAoB;EAC9B;EACA,SAAS,YAAY;GAEjB,OAAO,MADiB,aAAa,KAAK,IAAI;EAElD;EACA,GAAG,gBAAgB,CAAC;CACxB,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GACN,UAAU;GACV,SAAS,MAAM,MAAM;EACzB,CAAC;CACL,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;EACH,GAAG;EACH;CACJ;AACJ"}

package/dist/hooks/workspace/useFetchWorkspaces.d.ts

@@ -0,0 +1,46 @@
+import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
+import type { Workspace, WorkspaceListResponse } from "../../types/workspace.d.ts";
+type PageToken = string | null;
+type InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkspaceListResponse, Error, TData, QueryKey, PageToken>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+export type FetchInfiniteWorkspaceProps = {
+    workspace?: string;
+    pageSize?: number;
+    queryOptions?: InfiniteOptions<Workspace[]>;
+};
+/**
+ * useFetchWorkspaces
+ *
+ * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+ * workspaces with cursor-based pagination.
+ *
+ * It also:
+ * - flattens all pages into a single `Workspace[]` via `select`
+ *
+ * Important notes:
+ * - `query.data` returns a flat `Workspace[]` (all pages merged).
+ * - `workspace` is required by some API configurations to avoid being blocked.
+ *
+ * @param props - FetchInfiniteWorkspaceProps
+ *   - `workspace`: Current workspace name sent as a query param.
+ *   - `pageSize`: Number of workspaces to fetch per page.
+ *   - `queryOptions`: TanStack Query options passed through to `useInfiniteQuery`.
+ *
+ * Returns:
+ * @returns {object}
+ *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * Example:
+ * ```ts
+ * const { query } = useFetchWorkspaces({ workspace: "main", pageSize: 20 });
+ *
+ * // Flat list of all fetched workspaces
+ * const workspaces = query.data ?? [];
+ * ```
+ */
+export declare function useFetchWorkspaces({ workspace, pageSize, queryOptions }: FetchInfiniteWorkspaceProps): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<Workspace[], Error>;
+    queryKey: readonly unknown[];
+};
+export {};
+//# sourceMappingURL=useFetchWorkspaces.d.ts.map

package/dist/hooks/workspace/useFetchWorkspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkspaces.d.ts","sourceRoot":"","sources":["../../../src/hooks/workspace/useFetchWorkspaces.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1E,KAAK,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/B,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAC9B,uBAAuB,CAAC,qBAAqB,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,EACjF,UAAU,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CACnE,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,eAAe,CAAC,SAAS,EAAE,CAAC,CAAC;CAC/C,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,SAAS,EAAE,QAAa,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;EA4BzG"}

package/dist/hooks/workspace/useFetchWorkspaces.js

@@ -0,0 +1,66 @@
+import { useAxios } from "../useAxios.js";
+import { listWorkspaces } from "../../api/workspace.js";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/workspace/useFetchWorkspaces.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkspaces
+*
+* Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+* workspaces with cursor-based pagination.
+*
+* It also:
+* - flattens all pages into a single `Workspace[]` via `select`
+*
+* Important notes:
+* - `query.data` returns a flat `Workspace[]` (all pages merged).
+* - `workspace` is required by some API configurations to avoid being blocked.
+*
+* @param props - FetchInfiniteWorkspaceProps
+*   - `workspace`: Current workspace name sent as a query param.
+*   - `pageSize`: Number of workspaces to fetch per page.
+*   - `queryOptions`: TanStack Query options passed through to `useInfiniteQuery`.
+*
+* Returns:
+* @returns {object}
+*   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+*   - `queryKey`: the cache key used by React Query
+*
+* Example:
+* ```ts
+* const { query } = useFetchWorkspaces({ workspace: "main", pageSize: 20 });
+*
+* // Flat list of all fetched workspaces
+* const workspaces = query.data ?? [];
+* ```
+*/
+function useFetchWorkspaces({ workspace, pageSize = 10, queryOptions }) {
+	const { api } = useAxios();
+	const queryKey = ["workspaces", workspace ?? null];
+	const mergedQueryOptions = useMemo(() => ({
+		...defaultQueryOptions,
+		...queryOptions ?? {}
+	}), [queryOptions]);
+	return {
+		query: useInfiniteQuery({
+			queryKey,
+			initialPageParam: null,
+			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+			queryFn: async ({ pageParam }) => {
+				return await listWorkspaces(api, workspace, pageSize, pageParam ?? void 0);
+			},
+			select: (data) => data.pages.flatMap((p) => p.workspaces),
+			...mergedQueryOptions
+		}),
+		queryKey
+	};
+}
+//#endregion
+export { useFetchWorkspaces };
+
+//# sourceMappingURL=useFetchWorkspaces.js.map

package/dist/hooks/workspace/useFetchWorkspaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkspaces.js","names":[],"sources":["../../../src/hooks/workspace/useFetchWorkspaces.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useInfiniteQuery, type UseInfiniteQueryOptions, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { listWorkspaces } from \"@/api/workspace\";\nimport type { Workspace, WorkspaceListResponse } from \"@/types/workspace\";\n\ntype PageToken = string | null;\n\ntype InfiniteOptions<TData> = Omit<\n    UseInfiniteQueryOptions<WorkspaceListResponse, Error, TData, QueryKey, PageToken>,\n    \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\"\n>;\n\nexport type FetchInfiniteWorkspaceProps = {\n    workspace?: string;\n    pageSize?: number;\n    queryOptions?: InfiniteOptions<Workspace[]>;\n};\n\nconst defaultQueryOptions: InfiniteOptions<Workspace[]> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkspaces\n *\n * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve\n * workspaces with cursor-based pagination.\n *\n * It also:\n * - flattens all pages into a single `Workspace[]` via `select`\n *\n * Important notes:\n * - `query.data` returns a flat `Workspace[]` (all pages merged).\n * - `workspace` is required by some API configurations to avoid being blocked.\n *\n * @param props - FetchInfiniteWorkspaceProps\n *   - `workspace`: Current workspace name sent as a query param.\n *   - `pageSize`: Number of workspaces to fetch per page.\n *   - `queryOptions`: TanStack Query options passed through to `useInfiniteQuery`.\n *\n * Returns:\n * @returns {object}\n *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)\n *   - `queryKey`: the cache key used by React Query\n *\n * Example:\n * ```ts\n * const { query } = useFetchWorkspaces({ workspace: \"main\", pageSize: 20 });\n *\n * // Flat list of all fetched workspaces\n * const workspaces = query.data ?? [];\n * ```\n */\nexport function useFetchWorkspaces({ workspace, pageSize = 10, queryOptions }: FetchInfiniteWorkspaceProps) {\n    const { api } = useAxios();\n\n    const queryKey: QueryKey = [\"workspaces\", workspace ?? null];\n\n    const mergedQueryOptions = useMemo<InfiniteOptions<Workspace[]>>(() => ({\n        ...defaultQueryOptions,\n        ...(queryOptions ?? {}),\n    }), [queryOptions]);\n\n    const query = useInfiniteQuery<WorkspaceListResponse, Error, Workspace[], QueryKey, PageToken>({\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n\n        queryFn: async ({ pageParam }) => {\n            return await listWorkspaces(api, workspace, pageSize, pageParam ?? undefined);\n        },\n\n        select: (data) => data.pages.flatMap((p) => p.workspaces),\n\n        ...mergedQueryOptions,\n    });\n\n    return {\n        query,\n        queryKey,\n    };\n}\n"],"mappings":";;;;;AAoBA,IAAM,sBAAoD;CACtD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,mBAAmB,EAAE,WAAW,WAAW,IAAI,gBAA6C;CACxG,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAqB,CAAC,cAAc,aAAa,IAAI;CAE3D,MAAM,qBAAqB,eAA6C;EACpE,GAAG;EACH,GAAI,gBAAgB,CAAC;CACzB,IAAI,CAAC,YAAY,CAAC;CAgBlB,OAAO;EACH,OAfU,iBAAiF;GAC3F;GACA,kBAAkB;GAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;GAE5D,SAAS,OAAO,EAAE,gBAAgB;IAC9B,OAAO,MAAM,eAAe,KAAK,WAAW,UAAU,aAAa,KAAA,CAAS;GAChF;GAEA,SAAS,SAAS,KAAK,MAAM,SAAS,MAAM,EAAE,UAAU;GAExD,GAAG;EACP,CAGI;EACA;CACJ;AACJ"}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { EveryskApp } from "./EveryskApp";
+export type { EveryskAppProps, ProviderComponent } from "./EveryskApp";
+export { AppConfigContext } from "./contexts/appConfigContext";
+export { AppConfigProvider } from "./contexts/appConfigContext/provider";
+export { useAppConfig } from "./contexts/appConfigContext/useAppConfig";
+export type { AppConfigContextType, AppConfigProviderProps, } from "./contexts/appConfigContext/types";
+export { AppAlertContext } from "./contexts/appAlertContext";
+export { AppAlertProvider } from "./contexts/appAlertContext/provider";
+export { useAppAlert } from "./contexts/appAlertContext/useAppAlert";
+export type { AppAlertContextType, AppAlertState, ShowAlertOptions, } from "./contexts/appAlertContext/types";
+export { useAxios } from "./hooks/useAxios";
+export { toFilterTuple, buildQueryObject, buildQueryKey } from "./api/entityQuery";
+export { createQueryClient, getQueryFn } from "./lib/queryClient";
+export type { AnyRecord } from "./types/anyRecord";
+export type { BaseQueryParams, DeleteEntityDefaultResponse, DeleteEntityResponse, EntityDefaultResponse, EntityListResponse, EntityQueryOptions, EntityQueryParams, EntitySingleResponse, FetchEntitiesParams, FetchEntityParams, FilterClause, FilterExpression, FilterOperator, QueryObject, } from "./types/entityQuery";
+export * from "./portfolio";
+export * from "./datastore";
+export * from "./file";
+export * from "./profile";
+export * from "./workflow";
+export * from "./workspace";
+export * from "./ui";
+export * from "./theme";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,YAAY,EACR,oBAAoB,EACpB,sBAAsB,GACzB,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AACrE,YAAY,EACR,mBAAmB,EACnB,aAAa,EACb,gBAAgB,GACnB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGlE,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,YAAY,EACR,eAAe,EACf,2BAA2B,EAC3B,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,WAAW,GACd,MAAM,qBAAqB,CAAC;AAI7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,MAAM,CAAC;AACrB,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,50 @@
+import { components } from "./theme/overrides/index.js";
+import { DefaultLightTheme } from "./theme/themes/DefaultLight.js";
+import { DefaultDarkTheme } from "./theme/themes/DefaultDark.js";
+import { EveryskLightTheme } from "./theme/themes/EveryskLight.js";
+import { EveryskDarkTheme } from "./theme/themes/EveryskDark.js";
+import { MidnightEmberTheme } from "./theme/themes/MidnightEmber.js";
+import { getBrandTheme, getDefaultTheme, getTheme } from "./theme/themes/index.js";
+import { ThemeProvider } from "./theme/ThemeProvider.js";
+import { AppConfigContext } from "./contexts/appConfigContext/index.js";
+import { AppConfigProvider } from "./contexts/appConfigContext/provider.js";
+import { AppAlertContext } from "./contexts/appAlertContext/index.js";
+import { AppAlertProvider } from "./contexts/appAlertContext/provider.js";
+import { createQueryClient, getQueryFn } from "./lib/queryClient.js";
+import { EveryskApp } from "./EveryskApp.js";
+import { useAppConfig } from "./contexts/appConfigContext/useAppConfig.js";
+import { useAppAlert } from "./contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "./hooks/useAxios.js";
+import { buildQueryKey, buildQueryObject, toFilterTuple } from "./api/entityQuery.js";
+import { createPortfolio, deletePortfolio, getPortfolio, listPortfolios, updatePortfolio } from "./api/portfolio.js";
+import { useFetchPortfolio } from "./hooks/portfolio/useFetchPortfolio.js";
+import { useFetchPortfolios } from "./hooks/portfolio/useFetchPortfolios.js";
+import { usePortfolioMutations } from "./hooks/portfolio/usePortfolioMutations.js";
+import { createDatastore, deleteDatastore, getDatastore, listDatastores, updateDatastore } from "./api/datastore.js";
+import { useDatastoreMutations } from "./hooks/datastore/useDatastoreMutations.js";
+import { buildDatastoreProps, mergeDatastores, objectsToTable, tableToObjects } from "./lib/datastoreTable.js";
+import { useFetchDatastore } from "./hooks/datastore/useFetchDatastore.js";
+import { useFetchDatastores } from "./hooks/datastore/useFetchDatastores.js";
+import { createFile, deleteFile, getFile, listFiles, updateFile } from "./api/file.js";
+import { useFetchFile } from "./hooks/file/useFetchFile.js";
+import { useFetchFiles } from "./hooks/file/useFetchFiles.js";
+import { useFileMutations } from "./hooks/file/useFileMutations.js";
+import { DEV_PROFILE, getProfile } from "./api/profile.js";
+import { useFetchProfile } from "./hooks/profile/useFetchProfile.js";
+import { TERMINAL_RUN_STATUSES, getWorkerExecution, getWorkflow, getWorkflowExecution, listWorkerExecutions, listWorkflowExecutions, listWorkflows, pollWorkflowExecution, runWorkflow, runWorkflowAndGetResult } from "./api/workflow.js";
+import { useFetchWorkerExecution } from "./hooks/workflow/useFetchWorkerExecution.js";
+import { useFetchWorkerExecutions } from "./hooks/workflow/useFetchWorkerExecutions.js";
+import { useFetchWorkflow } from "./hooks/workflow/useFetchWorkflow.js";
+import { useFetchWorkflowExecution } from "./hooks/workflow/useFetchWorkflowExecution.js";
+import { useFetchWorkflowExecutions } from "./hooks/workflow/useFetchWorkflowExecutions.js";
+import { useFetchWorkflows } from "./hooks/workflow/useFetchWorkflows.js";
+import { useRunWorkflow } from "./hooks/workflow/useRunWorkflow.js";
+import { getWorkspace, listWorkspaces } from "./api/workspace.js";
+import { useFetchWorkspace } from "./hooks/workspace/useFetchWorkspace.js";
+import { useFetchWorkspaces } from "./hooks/workspace/useFetchWorkspaces.js";
+import { EveryskIcon } from "./components/ui/EveryskIcon/index.js";
+import { Footer } from "./components/ui/Footer/index.js";
+import { GlobalLoading } from "./components/ui/GlobalLoading/index.js";
+import { PageContainer } from "./components/ui/PageContainer/index.js";
+import { Toolbar } from "./components/ui/Toolbar/index.js";
+export { AppAlertContext, AppAlertProvider, AppConfigContext, AppConfigProvider, DEV_PROFILE, DefaultDarkTheme, DefaultLightTheme, EveryskApp, EveryskDarkTheme, EveryskIcon, EveryskLightTheme, Footer, GlobalLoading, MidnightEmberTheme, PageContainer, TERMINAL_RUN_STATUSES, ThemeProvider, Toolbar, buildDatastoreProps, buildQueryKey, buildQueryObject, components, createDatastore, createFile, createPortfolio, createQueryClient, deleteDatastore, deleteFile, deletePortfolio, getBrandTheme, getDatastore, getDefaultTheme, getFile, getPortfolio, getProfile, getQueryFn, getTheme, getWorkerExecution, getWorkflow, getWorkflowExecution, getWorkspace, listDatastores, listFiles, listPortfolios, listWorkerExecutions, listWorkflowExecutions, listWorkflows, listWorkspaces, mergeDatastores, objectsToTable, pollWorkflowExecution, runWorkflow, runWorkflowAndGetResult, tableToObjects, toFilterTuple, updateDatastore, updateFile, updatePortfolio, useAppAlert, useAppConfig, useAxios, useDatastoreMutations, useFetchDatastore, useFetchDatastores, useFetchFile, useFetchFiles, useFetchPortfolio, useFetchPortfolios, useFetchProfile, useFetchWorkerExecution, useFetchWorkerExecutions, useFetchWorkflow, useFetchWorkflowExecution, useFetchWorkflowExecutions, useFetchWorkflows, useFetchWorkspace, useFetchWorkspaces, useFileMutations, usePortfolioMutations, useRunWorkflow };