@lumerahq/ui 0.5.0

package/dist/use-automation-run-CbhXCKvM.js

@@ -0,0 +1,134 @@
+import { useQueryClient, useMutation, useQuery } from "@tanstack/react-query";
+import { useState, useRef, useEffect, useCallback } from "react";
+import { h as ensureAutomationRun, f as createAutomationRun, c as cancelAutomationRun, b as automationStatuses, l as getAutomationRun } from "./automations-DU4weMpK.js";
+function useAutomationRun(options) {
+  const {
+    agentId,
+    inputs,
+    externalId,
+    autoStart = true,
+    pollIntervalMs = 2e3,
+    dedupeWithExternalId = true,
+    onComplete,
+    onCreated,
+    onUpdate
+  } = options;
+  const queryClient = useQueryClient();
+  const [currentRunId, setCurrentRunId] = useState(null);
+  const [errorV, setErrorV] = useState(null);
+  const startMutation = useMutation({
+    mutationFn: async () => {
+      setErrorV(null);
+      if (!agentId) throw new Error("agentId is required");
+      if (externalId && dedupeWithExternalId) {
+        return ensureAutomationRun({ agentId, inputs, externalId });
+      }
+      return createAutomationRun({ agentId, inputs, externalId });
+    },
+    onSuccess: (data) => {
+      setCurrentRunId(data.id);
+      queryClient.setQueryData(["automation-run", data.id], data);
+      onCreated?.(data);
+      onUpdate?.(data);
+    },
+    onError: (err) => {
+      setErrorV(err instanceof Error ? err.message : "Unable to start automation");
+    }
+  });
+  const cancelMutation = useMutation({
+    mutationFn: async (runId) => {
+      return cancelAutomationRun(runId);
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(["automation-run", data.id], data);
+      onUpdate?.(data);
+    },
+    onError: (err) => {
+      setErrorV(err instanceof Error ? err.message : "Unable to cancel automation");
+    }
+  });
+  const {
+    data: run,
+    isError: isQueryError,
+    error: queryError,
+    refetch
+  } = useQuery({
+    queryKey: ["automation-run", currentRunId],
+    queryFn: async () => {
+      if (!currentRunId) return null;
+      return getAutomationRun(currentRunId);
+    },
+    enabled: !!currentRunId,
+    // Poll while active, stop when terminal
+    refetchInterval: (query) => {
+      const status = query.state.data?.status;
+      if (status && automationStatuses.TERMINAL_STATUSES.includes(status)) {
+        return false;
+      }
+      return pollIntervalMs;
+    },
+    // Immediately show data from setQueryData
+    initialData: void 0
+  });
+  const completedRunRef = useRef(null);
+  useEffect(() => {
+    if (run) {
+      onUpdate?.(run);
+      if (automationStatuses.TERMINAL_STATUSES.includes(run.status)) {
+        if (completedRunRef.current !== run.id) {
+          completedRunRef.current = run.id;
+          onComplete?.(run);
+        }
+      } else {
+        if (completedRunRef.current === run.id) {
+          completedRunRef.current = null;
+        }
+      }
+    }
+  }, [run, onComplete, onUpdate]);
+  useEffect(() => {
+    if (isQueryError && queryError) {
+      setErrorV(queryError instanceof Error ? queryError.message : "Failed to poll automation");
+    }
+  }, [isQueryError, queryError]);
+  const start = useCallback(async () => {
+    try {
+      const result = await startMutation.mutateAsync();
+      return result;
+    } catch {
+      return null;
+    }
+  }, [startMutation]);
+  const cancel = useCallback(async () => {
+    if (!currentRunId) return null;
+    try {
+      return await cancelMutation.mutateAsync(currentRunId);
+    } catch {
+      return null;
+    }
+  }, [cancelMutation, currentRunId]);
+  const refresh = useCallback(async () => {
+    if (!currentRunId) return start();
+    const result = await refetch();
+    return result.data ?? null;
+  }, [currentRunId, refetch, start]);
+  const autoStartedRef = useRef(false);
+  useEffect(() => {
+    if (autoStart && !autoStartedRef.current && !currentRunId) {
+      autoStartedRef.current = true;
+      void start();
+    }
+  }, [autoStart, currentRunId, start]);
+  return {
+    run: run ?? null,
+    status: run?.status ?? "idle",
+    isLoading: startMutation.isPending || cancelMutation.isPending,
+    error: errorV,
+    start,
+    refresh,
+    cancel
+  };
+}
+export {
+  useAutomationRun as u
+};

package/dist/use-sql-table-DuIu8eMY.js

@@ -0,0 +1,343 @@
+import { useQueryClient, useQuery, useMutation } from "@tanstack/react-query";
+import { useState, useCallback, useEffect, useMemo } from "react";
+import { w as listRunsByAgent, b as automationStatuses, f as createAutomationRun, o as onInitMessage } from "./automations-DU4weMpK.js";
+import { u as uploadFile, i as pbSql, k as pbUpdateRecord } from "./api-BNY_eNKa.js";
+function useAutomationAgent({
+  agentId,
+  limit = 5,
+  pollInterval = 3e3,
+  enabled = true
+}) {
+  const queryClient = useQueryClient();
+  const [page, setPage] = useState(0);
+  const [isStarting, setIsStarting] = useState(false);
+  const [startError, setStartError] = useState(null);
+  const queryKey = ["automation-runs", agentId, page];
+  const {
+    data: runs = [],
+    isLoading,
+    error: fetchError
+  } = useQuery({
+    queryKey,
+    queryFn: () => listRunsByAgent({
+      agentId,
+      limit,
+      offset: page * limit
+    }),
+    enabled: enabled && !!agentId,
+    refetchInterval: (query) => {
+      const hasActive = query.state.data?.some((run) => automationStatuses.ACTIVE_STATUSES.includes(run.status));
+      return hasActive ? pollInterval : false;
+    }
+  });
+  const startRun = useCallback(
+    async (inputs, options) => {
+      setIsStarting(true);
+      setStartError(null);
+      try {
+        const run = await createAutomationRun({
+          agentId,
+          inputs,
+          metadata: options?.metadata
+        });
+        setPage(0);
+        await queryClient.invalidateQueries({ queryKey: ["automation-runs", agentId] });
+        options?.onSuccess?.(run);
+        return run;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to start automation";
+        setStartError(message);
+        console.error("Automation start failed:", err);
+        options?.onError?.(err);
+        throw err;
+      } finally {
+        setIsStarting(false);
+      }
+    },
+    [agentId, queryClient]
+  );
+  const refresh = useCallback(() => {
+    return queryClient.invalidateQueries({ queryKey: ["automation-runs", agentId] });
+  }, [agentId, queryClient]);
+  return {
+    /** The list of automation runs for the current page. */
+    runs,
+    /** Whether the initial runs are loading. */
+    isLoading,
+    /** Error from fetching runs. */
+    fetchError,
+    /** Whether a startRun request is in progress. */
+    isStarting,
+    /** Error from the last startRun attempt. */
+    startError,
+    /** Current page index (0-based). */
+    page,
+    /** Set the current page index. */
+    setPage,
+    /** Function to start a new run. */
+    startRun,
+    /** Manually refresh the list. */
+    refresh,
+    /** Whether there are more items (heuristic based on limit). */
+    hasMore: runs.length === limit
+  };
+}
+function useFileUpload(options) {
+  const { collectionId, fieldName, onSuccess, onError } = options;
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const [result, setResult] = useState(null);
+  const upload = useCallback(
+    async (file) => {
+      setStatus("uploading");
+      setError(null);
+      setResult(null);
+      try {
+        const uploadResult = await uploadFile(file, { collectionId, fieldName });
+        setStatus("success");
+        setResult(uploadResult);
+        onSuccess?.(uploadResult);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Upload failed";
+        setStatus("error");
+        setError(message);
+        onError?.(err instanceof Error ? err : new Error(message));
+      }
+    },
+    [collectionId, fieldName, onSuccess, onError]
+  );
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+    setResult(null);
+  }, []);
+  return {
+    status,
+    error,
+    result,
+    upload,
+    reset,
+    isUploading: status === "uploading"
+  };
+}
+function usePbSql(request, options) {
+  return useQuery({
+    queryKey: ["pbSql", request],
+    queryFn: () => pbSql(request),
+    ...options
+  });
+}
+function usePbUpdate(options) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ collectionId, recordId, data }) => pbUpdateRecord(collectionId, recordId, data),
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: ["pbSql"] });
+      options?.onSuccess?.(...args);
+    },
+    ...options
+  });
+}
+function useLumeraUser() {
+  const [hostData, setHostData] = useState(null);
+  useEffect(() => {
+    const cleanup = onInitMessage((payload) => {
+      if (payload) {
+        setHostData(payload);
+      }
+    });
+    return () => {
+      cleanup();
+    };
+  }, []);
+  return hostData;
+}
+function buildFilterClause(filters) {
+  if (filters.length === 0) {
+    return { clause: "", args: [] };
+  }
+  const conditions = [];
+  const args = [];
+  filters.forEach((filter) => {
+    const col = filter.column;
+    switch (filter.operator) {
+      case "eq":
+        conditions.push(`${col} = ?`);
+        args.push(filter.value);
+        break;
+      case "neq":
+        conditions.push(`${col} != ?`);
+        args.push(filter.value);
+        break;
+      case "gt":
+        conditions.push(`${col} > ?`);
+        args.push(filter.value);
+        break;
+      case "gte":
+        conditions.push(`${col} >= ?`);
+        args.push(filter.value);
+        break;
+      case "lt":
+        conditions.push(`${col} < ?`);
+        args.push(filter.value);
+        break;
+      case "lte":
+        conditions.push(`${col} <= ?`);
+        args.push(filter.value);
+        break;
+      case "like":
+        conditions.push(`${col} LIKE ?`);
+        args.push(`%${filter.value}%`);
+        break;
+      case "in":
+        if (Array.isArray(filter.value) && filter.value.length > 0) {
+          const placeholders = filter.value.map(() => "?").join(", ");
+          conditions.push(`${col} IN (${placeholders})`);
+          args.push(...filter.value);
+        }
+        break;
+    }
+  });
+  return {
+    clause: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+    args
+  };
+}
+function buildOrderClause(sort) {
+  if (!sort) return "";
+  return `ORDER BY ${sort.column} ${sort.direction.toUpperCase()}`;
+}
+function useSqlTable(options) {
+  const {
+    baseSql,
+    queryKey = "sqlTable",
+    initialPage = 1,
+    initialPageSize = 25,
+    initialSort = null,
+    initialFilters = [],
+    enabled = true,
+    transformRow
+  } = options;
+  const queryClient = useQueryClient();
+  const [page, setPage] = useState(initialPage);
+  const [pageSize, setPageSize] = useState(initialPageSize);
+  const [sort, setSort] = useState(initialSort);
+  const [filters, setFilters] = useState(initialFilters);
+  const { sql, args } = useMemo(() => {
+    const { clause: whereClause, args: whereArgs } = buildFilterClause(filters);
+    const orderClause = buildOrderClause(sort);
+    const offset = (page - 1) * pageSize;
+    const fullSql = `
+      SELECT * FROM (${baseSql}) AS __data
+      ${whereClause}
+      ${orderClause}
+      LIMIT ? OFFSET ?
+    `.trim();
+    return {
+      sql: fullSql,
+      args: [...whereArgs, pageSize, offset]
+    };
+  }, [baseSql, filters, sort, page, pageSize]);
+  const { sql: countSql, args: countArgs } = useMemo(() => {
+    const { clause: whereClause, args: whereArgs } = buildFilterClause(filters);
+    const countQuery2 = `
+      SELECT COUNT(*) as count FROM (${baseSql}) AS __data
+      ${whereClause}
+    `.trim();
+    return { sql: countQuery2, args: whereArgs };
+  }, [baseSql, filters]);
+  const dataQuery = useQuery({
+    queryKey: [queryKey, "data", sql, args],
+    queryFn: () => pbSql({ sql, args }),
+    enabled
+  });
+  const countQuery = useQuery({
+    queryKey: [queryKey, "count", countSql, countArgs],
+    queryFn: () => pbSql({ sql: countSql, args: countArgs }),
+    enabled
+  });
+  const rows = useMemo(() => {
+    const rawRows = dataQuery.data?.rows ?? [];
+    if (transformRow) {
+      return rawRows.map(transformRow);
+    }
+    return rawRows;
+  }, [dataQuery.data?.rows, transformRow]);
+  const columns = useMemo(() => {
+    return dataQuery.data?.columns ?? [];
+  }, [dataQuery.data?.columns]);
+  const totalCount = countQuery.data?.rows?.[0]?.count ?? 0;
+  const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
+  const handleSetPage = useCallback((newPage) => {
+    setPage(Math.max(1, newPage));
+  }, []);
+  const handleSetPageSize = useCallback((newSize) => {
+    setPageSize(newSize);
+    setPage(1);
+  }, []);
+  const toggleSort = useCallback((column) => {
+    setSort((current) => {
+      if (current?.column === column) {
+        if (current.direction === "asc") {
+          return { column, direction: "desc" };
+        }
+        return null;
+      }
+      return { column, direction: "asc" };
+    });
+  }, []);
+  const addFilter = useCallback((filter) => {
+    setFilters((current) => {
+      const filtered = current.filter((f) => !(f.column === filter.column && f.operator === filter.operator));
+      return [...filtered, filter];
+    });
+    setPage(1);
+  }, []);
+  const removeFilter = useCallback((column, operator) => {
+    setFilters(
+      (current) => current.filter((f) => {
+        if (f.column !== column) return true;
+        if (operator && f.operator !== operator) return true;
+        return false;
+      })
+    );
+    setPage(1);
+  }, []);
+  const clearFilters = useCallback(() => {
+    setFilters([]);
+    setPage(1);
+  }, []);
+  const refresh = useCallback(() => {
+    queryClient.invalidateQueries({ queryKey: [queryKey] });
+  }, [queryClient, queryKey]);
+  return {
+    rows,
+    columns,
+    totalCount,
+    page,
+    pageSize,
+    totalPages,
+    setPage: handleSetPage,
+    setPageSize: handleSetPageSize,
+    sort,
+    setSort,
+    toggleSort,
+    filters,
+    addFilter,
+    removeFilter,
+    clearFilters,
+    setFilters,
+    isLoading: dataQuery.isLoading || countQuery.isLoading,
+    isFetching: dataQuery.isFetching || countQuery.isFetching,
+    error: dataQuery.error ?? countQuery.error ?? null,
+    refresh
+  };
+}
+export {
+  useFileUpload as a,
+  useLumeraUser as b,
+  usePbSql as c,
+  usePbUpdate as d,
+  useSqlTable as e,
+  useAutomationAgent as u
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@lumerahq/ui",
+  "version": "0.5.0",
+  "type": "module",
+  "sideEffects": [
+    "*.css"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./components": {
+      "types": "./dist/components/index.d.ts",
+      "import": "./dist/components/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
+    },
+    "./lib": {
+      "types": "./dist/lib/index.d.ts",
+      "import": "./dist/lib/index.js"
+    },
+    "./styles.css": "./dist/ui.css"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lumerahq/lumera.git"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.0.0",
+    "@tanstack/react-query": "^5.90.12",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.561.0",
+    "tailwind-merge": "^3.4.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.10",
+    "@fontsource-variable/inter": "^5.2.8",
+    "@tailwindcss/vite": "^4.1.17",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "shadcn": "^3.6.2",
+    "tailwindcss": "^4.1.17",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.4",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "build:lib": "tsc -b && vite build --mode lib",
+    "format": "biome format --write .",
+    "lint": "biome lint --write .",
+    "check": "biome check --write .",
+    "check:ci": "biome check .",
+    "preview": "vite preview"
+  }
+}