@btst/stack 1.11.0 → 2.0.0

package/dist/packages/stack/src/plugins/kanban/client/components/shared/task-card.cjs

@@ -0,0 +1,68 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const LucideIcons = require('lucide-react');
+const button = require('../../../../../../../ui/src/components/button.cjs');
+const badge = require('../../../../../../../ui/src/components/badge.cjs');
+const kanban = require('../../../../../../../ui/src/components/kanban.cjs');
+const dateFns = require('date-fns');
+const utils = require('../../../utils.cjs');
+const kanbanHooks = require('../../hooks/kanban-hooks.cjs');
+const userAvatar = require('./user-avatar.cjs');
+
+function TaskCardComponent({ task, onClick }) {
+  const priorityConfig = utils.getPriorityConfig(task.priority);
+  const { data: assignee } = kanbanHooks.useResolveUser(task.assigneeId);
+  return /* @__PURE__ */ jsxRuntime.jsx(kanban.KanbanItem, { value: task.id, asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "rounded-md border bg-card p-3 shadow-xs cursor-pointer hover:shadow-md transition-shadow",
+      onClick,
+      children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(kanban.KanbanItemHandle, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+            button.Button,
+            {
+              variant: "ghost",
+              size: "icon",
+              className: "h-6 w-6",
+              onClick: (e) => e.stopPropagation(),
+              children: /* @__PURE__ */ jsxRuntime.jsx(LucideIcons.GripVertical, { className: "h-3 w-3" })
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: "line-clamp-1 font-medium text-base flex-1 text-left cursor-pointer hover:text-primary",
+              title: task.title,
+              children: task.title
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            badge.Badge,
+            {
+              variant: priorityConfig.variant,
+              className: `pointer-events-none h-5 rounded-sm px-1.5 text-[11px] capitalize ${priorityConfig.className}`,
+              children: priorityConfig.label
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between text-muted-foreground text-xs", children: [
+          task.assigneeId ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(userAvatar.UserAvatar, { user: assignee ?? null, size: "sm" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "line-clamp-1", children: assignee?.name || "Assigned" })
+          ] }) : /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(userAvatar.UserAvatar, { user: null, size: "sm" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "line-clamp-1", children: "Unassigned" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("time", { className: "tabular-nums", children: dateFns.format(new Date(task.createdAt), "MMM d") })
+        ] })
+      ] })
+    }
+  ) });
+}
+const TaskCard = React.memo(TaskCardComponent);
+
+exports.TaskCard = TaskCard;

package/dist/packages/stack/src/plugins/kanban/client/components/shared/task-card.mjs

@@ -0,0 +1,66 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { memo } from 'react';
+import { GripVertical } from 'lucide-react';
+import { Button } from '../../../../../../../ui/src/components/button.mjs';
+import { Badge } from '../../../../../../../ui/src/components/badge.mjs';
+import { KanbanItem, KanbanItemHandle } from '../../../../../../../ui/src/components/kanban.mjs';
+import { format } from 'date-fns';
+import { getPriorityConfig } from '../../../utils.mjs';
+import { useResolveUser } from '../../hooks/kanban-hooks.mjs';
+import { UserAvatar } from './user-avatar.mjs';
+
+function TaskCardComponent({ task, onClick }) {
+  const priorityConfig = getPriorityConfig(task.priority);
+  const { data: assignee } = useResolveUser(task.assigneeId);
+  return /* @__PURE__ */ jsx(KanbanItem, { value: task.id, asChild: true, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "rounded-md border bg-card p-3 shadow-xs cursor-pointer hover:shadow-md transition-shadow",
+      onClick,
+      children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(KanbanItemHandle, { asChild: true, children: /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "ghost",
+              size: "icon",
+              className: "h-6 w-6",
+              onClick: (e) => e.stopPropagation(),
+              children: /* @__PURE__ */ jsx(GripVertical, { className: "h-3 w-3" })
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "line-clamp-1 font-medium text-base flex-1 text-left cursor-pointer hover:text-primary",
+              title: task.title,
+              children: task.title
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Badge,
+            {
+              variant: priorityConfig.variant,
+              className: `pointer-events-none h-5 rounded-sm px-1.5 text-[11px] capitalize ${priorityConfig.className}`,
+              children: priorityConfig.label
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between text-muted-foreground text-xs", children: [
+          task.assigneeId ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+            /* @__PURE__ */ jsx(UserAvatar, { user: assignee ?? null, size: "sm" }),
+            /* @__PURE__ */ jsx("span", { className: "line-clamp-1", children: assignee?.name || "Assigned" })
+          ] }) : /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+            /* @__PURE__ */ jsx(UserAvatar, { user: null, size: "sm" }),
+            /* @__PURE__ */ jsx("span", { className: "line-clamp-1", children: "Unassigned" })
+          ] }),
+          /* @__PURE__ */ jsx("time", { className: "tabular-nums", children: format(new Date(task.createdAt), "MMM d") })
+        ] })
+      ] })
+    }
+  ) });
+}
+const TaskCard = memo(TaskCardComponent);
+
+export { TaskCard };

package/dist/packages/stack/src/plugins/kanban/client/components/shared/user-avatar.cjs

@@ -0,0 +1,32 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const LucideIcons = require('lucide-react');
+const avatar = require('../../../../../../../ui/src/components/avatar.cjs');
+
+function getInitials(name) {
+  const parts = name.trim().split(/\s+/);
+  if (parts.length === 1) {
+    return parts[0]?.charAt(0).toUpperCase() || "";
+  }
+  return ((parts[0]?.charAt(0) || "") + (parts[parts.length - 1]?.charAt(0) || "")).toUpperCase();
+}
+function UserAvatarComponent({
+  user,
+  size = "sm",
+  className
+}) {
+  if (!user) {
+    return /* @__PURE__ */ jsxRuntime.jsx(avatar.Avatar, { size, className, title: "Unassigned", children: /* @__PURE__ */ jsxRuntime.jsx(avatar.AvatarFallback, { children: /* @__PURE__ */ jsxRuntime.jsx(LucideIcons.User, { className: "size-3 group-data-[size=default]/avatar:size-4 group-data-[size=lg]/avatar:size-5" }) }) });
+  }
+  const initials = getInitials(user.name);
+  return /* @__PURE__ */ jsxRuntime.jsxs(avatar.Avatar, { size, className, title: user.name, children: [
+    user.avatarUrl && /* @__PURE__ */ jsxRuntime.jsx(avatar.AvatarImage, { src: user.avatarUrl, alt: user.name }),
+    /* @__PURE__ */ jsxRuntime.jsx(avatar.AvatarFallback, { className: "bg-primary/10 text-primary font-medium", children: initials })
+  ] });
+}
+const UserAvatar = React.memo(UserAvatarComponent);
+
+exports.UserAvatar = UserAvatar;

package/dist/packages/stack/src/plugins/kanban/client/components/shared/user-avatar.mjs

@@ -0,0 +1,30 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { memo } from 'react';
+import { User } from 'lucide-react';
+import { Avatar, AvatarFallback, AvatarImage } from '../../../../../../../ui/src/components/avatar.mjs';
+
+function getInitials(name) {
+  const parts = name.trim().split(/\s+/);
+  if (parts.length === 1) {
+    return parts[0]?.charAt(0).toUpperCase() || "";
+  }
+  return ((parts[0]?.charAt(0) || "") + (parts[parts.length - 1]?.charAt(0) || "")).toUpperCase();
+}
+function UserAvatarComponent({
+  user,
+  size = "sm",
+  className
+}) {
+  if (!user) {
+    return /* @__PURE__ */ jsx(Avatar, { size, className, title: "Unassigned", children: /* @__PURE__ */ jsx(AvatarFallback, { children: /* @__PURE__ */ jsx(User, { className: "size-3 group-data-[size=default]/avatar:size-4 group-data-[size=lg]/avatar:size-5" }) }) });
+  }
+  const initials = getInitials(user.name);
+  return /* @__PURE__ */ jsxs(Avatar, { size, className, title: user.name, children: [
+    user.avatarUrl && /* @__PURE__ */ jsx(AvatarImage, { src: user.avatarUrl, alt: user.name }),
+    /* @__PURE__ */ jsx(AvatarFallback, { className: "bg-primary/10 text-primary font-medium", children: initials })
+  ] });
+}
+const UserAvatar = memo(UserAvatarComponent);
+
+export { UserAvatar };

package/dist/packages/stack/src/plugins/kanban/client/hooks/kanban-hooks.cjs

@@ -0,0 +1,391 @@
+"use client";
+'use strict';
+
+const reactQuery = require('@tanstack/react-query');
+const client = require('@btst/stack/plugins/client');
+const context = require('@btst/stack/context');
+const plugins_kanban_queryKeys = require('../../../../../../../plugins/kanban/query-keys.cjs');
+
+function isErrorResponse(response) {
+  return typeof response === "object" && response !== null && "error" in response && response.error !== null && response.error !== void 0;
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const errorObj = error;
+    const message = (typeof errorObj.message === "string" ? errorObj.message : null) || (typeof errorObj.error === "string" ? errorObj.error : null) || JSON.stringify(error);
+    const err = new Error(message);
+    Object.assign(err, error);
+    return err;
+  }
+  return new Error(String(error));
+}
+function useKanbanClient() {
+  const { apiBaseURL, apiBasePath, headers } = context.usePluginOverrides("kanban");
+  const client$1 = client.createApiClient({
+    baseURL: apiBaseURL,
+    basePath: apiBasePath
+  });
+  return { client: client$1, headers };
+}
+function useBoards(params) {
+  const { client, headers } = useKanbanClient();
+  const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(client, headers);
+  return reactQuery.useQuery({
+    ...queries.boards.list(params),
+    staleTime: 3e4
+  });
+}
+function useSuspenseBoards(params) {
+  const { client, headers } = useKanbanClient();
+  const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(client, headers);
+  const result = reactQuery.useSuspenseQuery({
+    ...queries.boards.list(params),
+    staleTime: 3e4
+  });
+  if (result.error && !result.isFetching) {
+    throw result.error;
+  }
+  return result;
+}
+function useBoard(boardId) {
+  const { client, headers } = useKanbanClient();
+  const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(client, headers);
+  return reactQuery.useQuery({
+    ...queries.boards.detail(boardId),
+    staleTime: 3e4,
+    enabled: !!boardId
+  });
+}
+function useSuspenseBoard(boardId) {
+  const { client, headers } = useKanbanClient();
+  const queries = plugins_kanban_queryKeys.createKanbanQueryKeys(client, headers);
+  const result = reactQuery.useSuspenseQuery({
+    ...queries.boards.detail(boardId),
+    staleTime: 3e4
+  });
+  if (result.error && !result.isFetching) {
+    throw result.error;
+  }
+  return result;
+}
+function useBoardMutations() {
+  const { client, headers } = useKanbanClient();
+  const queryClient = reactQuery.useQueryClient();
+  const createMutation = reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const response = await client("@post/boards", {
+        method: "POST",
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const updateMutation = reactQuery.useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      const response = await client("@put/boards/:id", {
+        method: "PUT",
+        params: { id },
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const deleteMutation = reactQuery.useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/boards/:id", {
+        method: "DELETE",
+        params: { id },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  return {
+    createBoard: createMutation.mutateAsync,
+    updateBoard: (id, data) => updateMutation.mutateAsync({ id, data }),
+    deleteBoard: deleteMutation.mutateAsync,
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error
+  };
+}
+function useColumnMutations() {
+  const { client, headers } = useKanbanClient();
+  const queryClient = reactQuery.useQueryClient();
+  const createMutation = reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const response = await client("@post/columns", {
+        method: "POST",
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const updateMutation = reactQuery.useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      const response = await client("@put/columns/:id", {
+        method: "PUT",
+        params: { id },
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const deleteMutation = reactQuery.useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/columns/:id", {
+        method: "DELETE",
+        params: { id },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const reorderMutation = reactQuery.useMutation({
+    mutationFn: async ({
+      boardId,
+      columnIds
+    }) => {
+      const response = await client("@post/columns/reorder", {
+        method: "POST",
+        body: { boardId, columnIds },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  return {
+    createColumn: createMutation.mutateAsync,
+    updateColumn: (id, data) => updateMutation.mutateAsync({ id, data }),
+    deleteColumn: deleteMutation.mutateAsync,
+    reorderColumns: (boardId, columnIds) => reorderMutation.mutateAsync({ boardId, columnIds }),
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    isReordering: reorderMutation.isPending,
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error,
+    reorderError: reorderMutation.error
+  };
+}
+function useTaskMutations() {
+  const { client, headers } = useKanbanClient();
+  const queryClient = reactQuery.useQueryClient();
+  const createMutation = reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const response = await client("@post/tasks", {
+        method: "POST",
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const updateMutation = reactQuery.useMutation({
+    mutationFn: async ({
+      id,
+      data
+    }) => {
+      const response = await client("@put/tasks/:id", {
+        method: "PUT",
+        params: { id },
+        body: data,
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const deleteMutation = reactQuery.useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/tasks/:id", {
+        method: "DELETE",
+        params: { id },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const moveMutation = reactQuery.useMutation({
+    mutationFn: async ({
+      taskId,
+      targetColumnId,
+      targetOrder
+    }) => {
+      const response = await client("@post/tasks/move", {
+        method: "POST",
+        body: { taskId, targetColumnId, targetOrder },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  const reorderMutation = reactQuery.useMutation({
+    mutationFn: async ({
+      columnId,
+      taskIds
+    }) => {
+      const response = await client("@post/tasks/reorder", {
+        method: "POST",
+        body: { columnId, taskIds },
+        headers
+      });
+      if (isErrorResponse(response)) {
+        const errorResponse = response;
+        throw toError(errorResponse.error);
+      }
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["boards"] });
+    }
+  });
+  return {
+    createTask: createMutation.mutateAsync,
+    updateTask: (id, data) => updateMutation.mutateAsync({ id, data }),
+    deleteTask: deleteMutation.mutateAsync,
+    moveTask: (taskId, targetColumnId, targetOrder) => moveMutation.mutateAsync({ taskId, targetColumnId, targetOrder }),
+    reorderTasks: (columnId, taskIds) => reorderMutation.mutateAsync({ columnId, taskIds }),
+    isCreating: createMutation.isPending,
+    isUpdating: updateMutation.isPending,
+    isDeleting: deleteMutation.isPending,
+    isMoving: moveMutation.isPending,
+    isReordering: reorderMutation.isPending,
+    createError: createMutation.error,
+    updateError: updateMutation.error,
+    deleteError: deleteMutation.error,
+    moveError: moveMutation.error,
+    reorderError: reorderMutation.error
+  };
+}
+function useResolveUser(userId) {
+  const { resolveUser } = context.usePluginOverrides("kanban");
+  return reactQuery.useQuery({
+    queryKey: ["kanban", "users", userId],
+    queryFn: async () => {
+      if (!userId) return null;
+      const result = await resolveUser(userId);
+      return result;
+    },
+    enabled: !!userId,
+    staleTime: 5 * 60 * 1e3,
+    // Cache user info for 5 minutes
+    gcTime: 10 * 60 * 1e3
+    // Keep in cache for 10 minutes
+  });
+}
+function useSearchUsers(query, boardId) {
+  const { searchUsers } = context.usePluginOverrides("kanban");
+  return reactQuery.useQuery({
+    queryKey: ["kanban", "users", "search", query, boardId],
+    queryFn: async () => {
+      const result = await searchUsers(query, boardId);
+      return result;
+    },
+    staleTime: 3e4
+    // Cache search results for 30 seconds
+  });
+}
+
+exports.useBoard = useBoard;
+exports.useBoardMutations = useBoardMutations;
+exports.useBoards = useBoards;
+exports.useColumnMutations = useColumnMutations;
+exports.useResolveUser = useResolveUser;
+exports.useSearchUsers = useSearchUsers;
+exports.useSuspenseBoard = useSuspenseBoard;
+exports.useSuspenseBoards = useSuspenseBoards;
+exports.useTaskMutations = useTaskMutations;