@ploykit/ui 0.0.0-stage → 0.1.1

package/dist/hooks/useLogin.d.ts

@@ -0,0 +1,10 @@
+export interface UseLoginResult {
+    sendCode(email: string): Promise<void>;
+    submit(email: string, code: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    loading: boolean;
+    error: string | null;
+}
+export declare function useLogin(): UseLoginResult;

package/dist/hooks/useLogin.js

@@ -0,0 +1,39 @@
+import { useCallback, useState } from 'react';
+import { api } from '@ploykit/client';
+import { useAuthCtx } from '../provider/PloykitProvider';
+export function useLogin() {
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const { refresh } = useAuthCtx();
+    const sendCode = useCallback(async (email) => {
+        setError(null);
+        setLoading(true);
+        try {
+            await api.post('/auth/send-code', { email });
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : '发送失败');
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    const submit = useCallback(async (email, code) => {
+        setError(null);
+        setLoading(true);
+        try {
+            await api.post('/auth/verify-code', { email, code });
+            await refresh();
+            return { ok: true };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : '登录失败';
+            setError(msg);
+            return { ok: false, error: msg };
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [refresh]);
+    return { sendCode, submit, loading, error };
+}

package/dist/hooks/useMembers.d.ts

@@ -0,0 +1,125 @@
+import type { components } from '@ploykit/client';
+export type PKMember = components['schemas']['Member'];
+export type PKInvitation = components['schemas']['Invitation'];
+export type PKShareLink = components['schemas']['ShareLink'];
+export type PKInvitationWithWorkspace = components['schemas']['InvitationWithWorkspace'];
+export type PKMemberPage = components['schemas']['MemberPage'];
+export type PKInvitationPage = components['schemas']['InvitationPage'];
+export type PKShareLinkPage = components['schemas']['ShareLinkPage'];
+export interface ListQuery {
+    page: number;
+    pageSize?: number;
+}
+export interface ListPages {
+    members: number;
+    invitations: number;
+    shareLinks: number;
+}
+export declare const LIST_PAGE_SIZE = 50;
+export interface CreateShareLinkResult {
+    link: PKShareLink;
+    code: string;
+}
+export declare const ASSIGNABLE_ROLES: readonly ["admin", "member"];
+export declare function useMembers(pages: ListPages): {
+    wsId: string;
+    myRole: "owner" | "admin" | "member" | null;
+    members: {
+        user_id: string;
+        email: string;
+        display_name: string;
+        role: "owner" | "admin" | "member";
+        created_at: string;
+    }[];
+    membersTotal: number;
+    invitations: {
+        id: string;
+        workspace_id: string;
+        email: string;
+        role: "owner" | "admin" | "member";
+        status: "pending" | "accepted" | "declined" | "revoked" | "expired";
+        expires_at: string;
+        created_at: string;
+    }[];
+    invitationsTotal: number;
+    shareLinks: {
+        id: string;
+        code_prefix: string;
+        role: "admin" | "member";
+        max_uses: number;
+        uses: number;
+        expires_at: string;
+        created_at: string;
+    }[];
+    shareLinksTotal: number;
+    loading: boolean;
+    membersError: Error | null;
+    invitationsError: Error | null;
+    shareLinksError: Error | null;
+    refetchAll: () => Promise<void>;
+};
+export declare function useMemberMutations(): {
+    invite: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        workspace_id: string;
+        email: string;
+        role: "owner" | "admin" | "member";
+        status: "pending" | "accepted" | "declined" | "revoked" | "expired";
+        expires_at: string;
+        created_at: string;
+    }, Error, {
+        email: string;
+        role: string;
+    }, unknown>;
+    revokeInvitation: import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+    updateRole: import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+        userId: string;
+        role: string;
+    }, unknown>;
+    removeMember: import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+    transferOwnership: import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+    createShareLink: import("@tanstack/react-query").UseMutationResult<CreateShareLinkResult, Error, {
+        role: string;
+        max_uses: number;
+        ttl_hours: number;
+    }, unknown>;
+    revokeShareLink: import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+};
+export declare function useMyInvitations(): {
+    invitations: ({
+        id: string;
+        workspace_id: string;
+        email: string;
+        role: "owner" | "admin" | "member";
+        status: "pending" | "accepted" | "declined" | "revoked" | "expired";
+        expires_at: string;
+        created_at: string;
+    } & {
+        workspace_name: string;
+        workspace_slug: string;
+    })[];
+    loading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<({
+        id: string;
+        workspace_id: string;
+        email: string;
+        role: "owner" | "admin" | "member";
+        status: "pending" | "accepted" | "declined" | "revoked" | "expired";
+        expires_at: string;
+        created_at: string;
+    } & {
+        workspace_name: string;
+        workspace_slug: string;
+    })[], Error>>;
+    accept: import("@tanstack/react-query").UseMutationResult<{
+        id: string;
+        slug: string;
+        name: string;
+        plan_code: string;
+        created_at: string;
+    } & {
+        role: "owner" | "admin" | "member";
+    }, Error, string, unknown>;
+    decline: import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+};

package/dist/hooks/useMembers.js

@@ -0,0 +1,127 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useApi } from './useApi';
+import { useWorkspace } from './useWorkspace';
+import { queryKeys } from '../provider/PloykitProvider';
+export const LIST_PAGE_SIZE = 50;
+const listQuery = (q) => `?page=${q.page}&page_size=${q.pageSize ?? LIST_PAGE_SIZE}`;
+export const ASSIGNABLE_ROLES = ['admin', 'member'];
+export function useMembers(pages) {
+    const { current } = useWorkspace();
+    const api = useApi();
+    const wsId = current?.id ?? '';
+    const membersQ = useQuery({
+        queryKey: [...queryKeys.members(wsId), pages.members],
+        queryFn: () => api.get(`/api/workspaces/${wsId}/members${listQuery({ page: pages.members })}`),
+        enabled: !!wsId,
+    });
+    const invitationsQ = useQuery({
+        queryKey: [...queryKeys.invitations(wsId), pages.invitations],
+        queryFn: () => api.get(`/api/workspaces/${wsId}/invitations${listQuery({ page: pages.invitations })}`),
+        enabled: !!wsId,
+    });
+    const shareLinksQ = useQuery({
+        queryKey: [...queryKeys.shareLinks(wsId), pages.shareLinks],
+        queryFn: () => api.get(`/api/workspaces/${wsId}/share-links${listQuery({ page: pages.shareLinks })}`),
+        enabled: !!wsId,
+    });
+    return {
+        wsId,
+        myRole: current?.role ?? null,
+        members: membersQ.data?.items ?? [],
+        membersTotal: membersQ.data?.total ?? 0,
+        invitations: invitationsQ.data?.items ?? [],
+        invitationsTotal: invitationsQ.data?.total ?? 0,
+        shareLinks: shareLinksQ.data?.items ?? [],
+        shareLinksTotal: shareLinksQ.data?.total ?? 0,
+        loading: !!wsId && (membersQ.isPending || invitationsQ.isPending || shareLinksQ.isPending),
+        membersError: membersQ.error,
+        invitationsError: invitationsQ.error,
+        shareLinksError: shareLinksQ.error,
+        refetchAll: async () => {
+            await Promise.all([
+                membersQ.refetch(),
+                invitationsQ.refetch(),
+                shareLinksQ.refetch(),
+            ]);
+        },
+    };
+}
+export function useMemberMutations() {
+    const { current } = useWorkspace();
+    const api = useApi();
+    const qc = useQueryClient();
+    const wsId = current?.id ?? '';
+    const base = `/api/workspaces/${wsId}`;
+    const invalidateAll = async () => {
+        await Promise.all([
+            qc.invalidateQueries({ queryKey: queryKeys.members(wsId) }),
+            qc.invalidateQueries({ queryKey: queryKeys.invitations(wsId) }),
+            qc.invalidateQueries({ queryKey: queryKeys.shareLinks(wsId) }),
+        ]);
+    };
+    const invite = useMutation({
+        mutationFn: (v) => api.post(`${base}/invitations`, v),
+        onSuccess: invalidateAll,
+    });
+    const revokeInvitation = useMutation({
+        mutationFn: (invId) => api.delete(`${base}/invitations/${invId}`),
+        onSuccess: invalidateAll,
+    });
+    const updateRole = useMutation({
+        mutationFn: (v) => api.patch(`${base}/members/${v.userId}`, { role: v.role }),
+        onSuccess: invalidateAll,
+    });
+    const removeMember = useMutation({
+        mutationFn: (userId) => api.delete(`${base}/members/${userId}`),
+        onSuccess: invalidateAll,
+    });
+    const transferOwnership = useMutation({
+        mutationFn: (userId) => api.post(`${base}/transfer-ownership`, { user_id: userId }),
+        onSuccess: async () => {
+            await invalidateAll();
+            await qc.invalidateQueries({ queryKey: queryKeys.workspace });
+        },
+    });
+    const createShareLink = useMutation({
+        mutationFn: (v) => api.post(`${base}/share-links`, v),
+        onSuccess: invalidateAll,
+    });
+    const revokeShareLink = useMutation({
+        mutationFn: (linkId) => api.delete(`${base}/share-links/${linkId}`),
+        onSuccess: invalidateAll,
+    });
+    return {
+        invite, revokeInvitation, updateRole, removeMember, transferOwnership,
+        createShareLink, revokeShareLink,
+    };
+}
+export function useMyInvitations() {
+    const api = useApi();
+    const qc = useQueryClient();
+    const list = useQuery({
+        queryKey: queryKeys.myInvitations,
+        queryFn: () => api.get('/api/invitations/mine'),
+    });
+    const invalidate = () => qc.invalidateQueries({ queryKey: queryKeys.myInvitations });
+    const accept = useMutation({
+        mutationFn: (id) => api.post(`/api/invitations/${id}/accept`),
+        onSuccess: async () => {
+            await Promise.all([
+                invalidate(),
+                qc.invalidateQueries({ queryKey: queryKeys.workspace }),
+            ]);
+        },
+    });
+    const decline = useMutation({
+        mutationFn: (id) => api.post(`/api/invitations/${id}/decline`),
+        onSuccess: invalidate,
+    });
+    return {
+        invitations: list.data ?? [],
+        loading: list.isPending,
+        error: list.error,
+        refetch: list.refetch,
+        accept,
+        decline,
+    };
+}

package/dist/hooks/useNotificationPrefs.d.ts

@@ -0,0 +1,20 @@
+export interface NotificationPreference {
+    notification_type: string;
+    email_enabled: boolean;
+    in_app_enabled: boolean;
+    updated_at: string;
+}
+export declare function useNotificationPrefs(): {
+    prefs: NotificationPreference[];
+    loading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NotificationPreference[], Error>>;
+};
+export declare function useSetNotificationPref(): {
+    setPref: (type: string, channels: {
+        email_enabled?: boolean;
+        in_app_enabled?: boolean;
+    }) => Promise<NotificationPreference>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useNotificationPrefs.js

@@ -0,0 +1,42 @@
+import { useCallback } from 'react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { api } from '@ploykit/client';
+import { queryKeys } from '../provider/PloykitProvider';
+export function useNotificationPrefs() {
+    const q = useQuery({
+        queryKey: queryKeys.notificationPrefs,
+        queryFn: async () => {
+            const data = await api.get('/api/notification-preferences');
+            return data?.items ?? [];
+        },
+    });
+    return { prefs: q.data ?? [], loading: q.isPending, error: q.error, refetch: q.refetch };
+}
+export function useSetNotificationPref() {
+    const qc = useQueryClient();
+    const m = useMutation({
+        mutationFn: (v) => api.put(`/api/notification-preferences/${encodeURIComponent(v.type)}`, { email_enabled: v.email_enabled, in_app_enabled: v.in_app_enabled }),
+        onMutate: async (v) => {
+            await qc.cancelQueries({ queryKey: queryKeys.notificationPrefs });
+            const prev = qc.getQueryData(queryKeys.notificationPrefs) ?? [];
+            const existing = prev.find((p) => p.notification_type === v.type);
+            const next = {
+                notification_type: v.type,
+                email_enabled: v.email_enabled ?? existing?.email_enabled ?? true,
+                in_app_enabled: v.in_app_enabled ?? existing?.in_app_enabled ?? true,
+                updated_at: new Date().toISOString(),
+            };
+            qc.setQueryData(queryKeys.notificationPrefs, existing
+                ? prev.map((p) => (p.notification_type === v.type ? next : p))
+                : [...prev, next]);
+            return { prev };
+        },
+        onError: (_err, _v, ctx) => {
+            if (ctx?.prev)
+                qc.setQueryData(queryKeys.notificationPrefs, ctx.prev);
+        },
+        onSettled: () => qc.invalidateQueries({ queryKey: queryKeys.notificationPrefs }),
+    });
+    const setPref = useCallback((type, channels) => m.mutateAsync({ type, ...channels }), [m]);
+    return { setPref, loading: m.isPending, error: m.error };
+}

package/dist/hooks/usePasswordReset.d.ts

@@ -0,0 +1,5 @@
+export interface UsePasswordResetResult {
+    requestReset(email: string): Promise<void>;
+    reset(email: string, token: string, newPassword: string): Promise<void>;
+}
+export declare function usePasswordReset(): UsePasswordResetResult;

package/dist/hooks/usePasswordReset.js

@@ -0,0 +1,12 @@
+import { useCallback } from 'react';
+import { useApi } from './useApi';
+export function usePasswordReset() {
+    const api = useApi();
+    const requestReset = useCallback(async (email) => {
+        await api.post('/auth/forgot-password', { email });
+    }, [api]);
+    const reset = useCallback(async (email, token, newPassword) => {
+        await api.post('/auth/reset-password', { email, token, new_password: newPassword });
+    }, [api]);
+    return { requestReset, reset };
+}

package/dist/hooks/useSEO.d.ts

@@ -0,0 +1,6 @@
+export interface SeoMeta {
+    title?: string;
+    description?: string;
+    ogImage?: string;
+}
+export declare function useSEO(meta: SeoMeta): void;

package/dist/hooks/useSEO.js

@@ -0,0 +1,14 @@
+import { emitDirective } from '@ploykit/runtime';
+export function useSEO(meta) {
+    const entries = [];
+    if (meta.title)
+        entries.push({ tag: 'title', children: meta.title });
+    if (meta.description) {
+        entries.push({ tag: 'meta', attrs: { name: 'description', content: meta.description } });
+    }
+    if (meta.ogImage) {
+        entries.push({ tag: 'meta', attrs: { property: 'og:image', content: meta.ogImage } });
+        entries.push({ tag: 'meta', attrs: { name: 'twitter:card', content: 'summary_large_image' } });
+    }
+    emitDirective('head', entries);
+}

package/dist/hooks/useSessions.d.ts

@@ -0,0 +1,20 @@
+import type { components } from '@ploykit/client';
+export type SessionInfo = components['schemas']['SessionInfo'] & {
+    current?: boolean;
+};
+export declare function useSessions(): {
+    sessions: SessionInfo[];
+    loading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<SessionInfo[], Error>>;
+};
+export declare function useRevokeSession(): {
+    revoke: (id: string) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+};
+export declare function useRevokeAllSessions(): {
+    revokeAll: () => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useSessions.js

@@ -0,0 +1,38 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { api } from '@ploykit/client';
+import { queryKeys } from '../provider/PloykitProvider';
+function normalize(data) {
+    const list = Array.isArray(data) ? data : data?.items;
+    return Array.isArray(list) ? list : [];
+}
+export function useSessions() {
+    const q = useQuery({
+        queryKey: queryKeys.sessions,
+        queryFn: async () => normalize(await api.get('/auth/sessions')),
+    });
+    return { sessions: q.data ?? [], loading: q.isPending, error: q.error, refetch: q.refetch };
+}
+export function useRevokeSession() {
+    const qc = useQueryClient();
+    const m = useMutation({
+        mutationFn: (id) => api.delete(`/auth/sessions/${id}`),
+        onSuccess: () => qc.invalidateQueries({ queryKey: queryKeys.sessions }),
+    });
+    return {
+        revoke: (id) => m.mutateAsync(id),
+        loading: m.isPending,
+        error: m.error,
+    };
+}
+export function useRevokeAllSessions() {
+    const qc = useQueryClient();
+    const m = useMutation({
+        mutationFn: () => api.delete('/auth/sessions'),
+        onSuccess: () => qc.invalidateQueries({ queryKey: queryKeys.sessions }),
+    });
+    return {
+        revokeAll: () => m.mutateAsync(),
+        loading: m.isPending,
+        error: m.error,
+    };
+}

package/dist/hooks/useSiteConfig.d.ts

@@ -0,0 +1,12 @@
+export declare const SITE_CONFIG_QUERY_KEY: readonly ["site-config"];
+export interface SiteConfig {
+    oauth_providers?: string[];
+    billing_channels?: string[];
+    banner_text?: string;
+    banner_kind?: string;
+    maintenance_mode?: string;
+    allow_signup?: string;
+    allowed_domains?: string;
+    mail_mode?: string;
+}
+export declare function useSiteConfig(): import("@tanstack/react-query").UseQueryResult<SiteConfig, Error>;

package/dist/hooks/useSiteConfig.js

@@ -0,0 +1,11 @@
+import { useQuery } from '@tanstack/react-query';
+import { api } from '@ploykit/client';
+export const SITE_CONFIG_QUERY_KEY = ['site-config'];
+export function useSiteConfig() {
+    return useQuery({
+        queryKey: SITE_CONFIG_QUERY_KEY,
+        queryFn: () => api.get('/config'),
+        staleTime: 5 * 60_000,
+        retry: false,
+    });
+}

package/dist/hooks/useTokens.d.ts

@@ -0,0 +1,36 @@
+import type { components } from '@ploykit/client';
+export type PAT = components['schemas']['PAT'];
+export type CreatePATResult = components['schemas']['CreatePATResponse'];
+export declare function useTokens(): {
+    tokens: {
+        id: string;
+        name: string;
+        prefix: string;
+        expires_at?: string;
+        last_used_at?: string;
+        created_at: string;
+    }[];
+    loading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        id: string;
+        name: string;
+        prefix: string;
+        expires_at?: string;
+        last_used_at?: string;
+        created_at: string;
+    }[], Error>>;
+};
+export declare function useCreateToken(): {
+    create: (name: string, ttlHours?: number) => Promise<{
+        pat: components["schemas"]["PAT"];
+        token: string;
+    }>;
+    loading: boolean;
+    error: Error | null;
+};
+export declare function useRevokeToken(): {
+    revoke: (id: string) => Promise<void>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useTokens.js

@@ -0,0 +1,35 @@
+import { useCallback } from 'react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { api } from '@ploykit/client';
+import { queryKeys } from '../provider/PloykitProvider';
+export function useTokens() {
+    const q = useQuery({
+        queryKey: queryKeys.tokens,
+        queryFn: async () => {
+            const data = await api.get('/api/tokens');
+            return Array.isArray(data) ? data : [];
+        },
+    });
+    return { tokens: q.data ?? [], loading: q.isPending, error: q.error, refetch: q.refetch };
+}
+export function useCreateToken() {
+    const qc = useQueryClient();
+    const m = useMutation({
+        mutationFn: (v) => api.post('/api/tokens', v),
+        onSuccess: () => qc.invalidateQueries({ queryKey: queryKeys.tokens }),
+    });
+    const create = useCallback((name, ttlHours) => m.mutateAsync({ name, ttl_hours: ttlHours }), [m]);
+    return { create, loading: m.isPending, error: m.error };
+}
+export function useRevokeToken() {
+    const qc = useQueryClient();
+    const m = useMutation({
+        mutationFn: (id) => api.delete(`/api/tokens/${id}`),
+        onSuccess: () => qc.invalidateQueries({ queryKey: queryKeys.tokens }),
+    });
+    return {
+        revoke: (id) => m.mutateAsync(id),
+        loading: m.isPending,
+        error: m.error,
+    };
+}

package/dist/hooks/useUsage.d.ts

@@ -0,0 +1,20 @@
+import type { components } from '@ploykit/client';
+export type PKUsageResp = components['schemas']['UsageResp'];
+export type PKUsageItem = components['schemas']['UsageItem'];
+export declare function useUsage(): {
+    wsId: string;
+    usage: {
+        workspace_id: string;
+        plan_code: string;
+        period: string;
+        items: components["schemas"]["UsageItem"][];
+    } | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        workspace_id: string;
+        plan_code: string;
+        period: string;
+        items: components["schemas"]["UsageItem"][];
+    }, Error>>;
+};

package/dist/hooks/useUsage.js

@@ -0,0 +1,21 @@
+import { useQuery } from '@tanstack/react-query';
+import { useApi } from './useApi';
+import { useWorkspace } from './useWorkspace';
+import { queryKeys } from '../provider/PloykitProvider';
+export function useUsage() {
+    const { current } = useWorkspace();
+    const api = useApi();
+    const wsId = current?.id ?? '';
+    const q = useQuery({
+        queryKey: queryKeys.usage(wsId),
+        queryFn: () => api.get('/api/usage'),
+        enabled: !!wsId,
+    });
+    return {
+        wsId,
+        usage: wsId ? (q.data ?? null) : null,
+        loading: !!wsId && q.isPending,
+        error: q.error,
+        refetch: q.refetch,
+    };
+}

package/dist/hooks/useWorkspace.d.ts

@@ -0,0 +1,26 @@
+import { type PKWorkspace } from '../provider/PloykitProvider';
+export declare function useWorkspace(): import("../provider/PloykitProvider").WorkspaceContextValue;
+export declare function useWorkspaceSwitch(): {
+    current: ({
+        id: string;
+        slug: string;
+        name: string;
+        plan_code: string;
+        created_at: string;
+    } & {
+        role: "owner" | "admin" | "member";
+    }) | null;
+    list: ({
+        id: string;
+        slug: string;
+        name: string;
+        plan_code: string;
+        created_at: string;
+    } & {
+        role: "owner" | "admin" | "member";
+    })[];
+    switchTo: (id: string) => void;
+    create: (name: string, slug: string) => Promise<PKWorkspace | null>;
+    creating: boolean;
+    error: unknown;
+};

package/dist/hooks/useWorkspace.js

@@ -0,0 +1,32 @@
+import { useCallback, useState } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { api } from '@ploykit/client';
+import { useAuthCtx, useWorkspaceCtx, queryKeys, } from '../provider/PloykitProvider';
+export function useWorkspace() {
+    return useWorkspaceCtx();
+}
+export function useWorkspaceSwitch() {
+    const { workspaces } = useAuthCtx();
+    const { current, switchTo } = useWorkspaceCtx();
+    const qc = useQueryClient();
+    const [creating, setCreating] = useState(false);
+    const [error, setError] = useState(null);
+    const create = useCallback(async (name, slug) => {
+        setCreating(true);
+        setError(null);
+        try {
+            const ws = await api.post('/api/workspaces', { name, slug });
+            await qc.invalidateQueries({ queryKey: queryKeys.workspace });
+            switchTo(ws.id);
+            return ws;
+        }
+        catch (e) {
+            setError(e);
+            return null;
+        }
+        finally {
+            setCreating(false);
+        }
+    }, [qc, switchTo]);
+    return { current, list: workspaces, switchTo, create, creating, error };
+}