@tuturuuu/ui 0.37.1 → 0.38.0

package/src/components/ui/text-editor/tool-bar.tsx

@@ -46,9 +46,7 @@ import { ToolbarButton, ToolbarSeparator } from './toolbar-controls';
 
 type LinkEditorContext = 'bubble' | 'popover' | null;
 
-// ---------------------------------------------------------------------------
 // Main ToolBar (BubbleMenu)
-// ---------------------------------------------------------------------------
 
 interface ToolBarProps {
   editor: Editor | null;
@@ -59,12 +57,14 @@ interface ToolBarProps {
   onConvertToTask?: () => void | Promise<void>;
   /** When true, the BubbleMenu is hidden because the fixed toolbar is visible */
   fixedToolbarVisible?: boolean;
+  allowEmbeds?: boolean;
   toggleBlockLabel?: string;
 }
 
 export function ToolBar({
   editor,
   fixedToolbarVisible,
+  allowEmbeds = true,
   workspaceId,
   onImageUpload,
   onConvertToTask,
@@ -459,9 +459,7 @@ export function ToolBar({
     toast.success('YouTube video added');
   }, [editor, youtubeUrl]);
 
-  // -----------------------------------------------------------------------
   // Render helpers
-  // -----------------------------------------------------------------------
 
   /** Renders the core formatting buttons (used by both fixed and bubble toolbar) */
   const renderFormattingOptions = useCallback(
@@ -478,11 +476,9 @@ export function ToolBar({
           />
         ))}
 
-        {/* Color controls */}
         <ToolbarSeparator />
         <TextEditorColorControls editor={editor} />
 
-        {/* Link */}
         <ToolbarSeparator />
         <ToolbarButton
           id="link"
@@ -491,8 +487,7 @@ export function ToolBar({
           onClick={() => openLinkEditor(source)}
         />
 
-        {/* Media uploads */}
-        {workspaceId && onImageUpload && (
+        {onImageUpload && (
           <>
             <ToolbarSeparator />
             <ToolbarButton
@@ -508,30 +503,33 @@ export function ToolBar({
               onClick={triggerImageUpload}
               disabled={isUploadingImage}
             />
-            <ToolbarButton
-              id="video"
-              icon={
-                isUploadingVideo ? (
-                  <Loader2 className="size-4 animate-spin" />
-                ) : (
-                  <FileVideo className="size-4" />
-                )
-              }
-              pressed={false}
-              onClick={triggerVideoUpload}
-              disabled={isUploadingVideo}
-            />
+            {workspaceId && (
+              <ToolbarButton
+                id="video"
+                icon={
+                  isUploadingVideo ? (
+                    <Loader2 className="size-4 animate-spin" />
+                  ) : (
+                    <FileVideo className="size-4" />
+                  )
+                }
+                pressed={false}
+                onClick={triggerVideoUpload}
+                disabled={isUploadingVideo}
+              />
+            )}
           </>
         )}
 
-        <ToolbarButton
-          id="youtube"
-          icon={<YoutubeIcon className="size-4" />}
-          pressed={showYoutubeInput}
-          onClick={() => setShowYoutubeInput(!showYoutubeInput)}
-        />
+        {allowEmbeds && (
+          <ToolbarButton
+            id="youtube"
+            icon={<YoutubeIcon className="size-4" />}
+            pressed={showYoutubeInput}
+            onClick={() => setShowYoutubeInput(!showYoutubeInput)}
+          />
+        )}
 
-        {/* Convert to task */}
         {onConvertToTask && (
           <>
             <ToolbarSeparator />
@@ -557,6 +555,7 @@ export function ToolBar({
       triggerVideoUpload,
       isUploadingVideo,
       showYoutubeInput,
+      allowEmbeds,
       onConvertToTask,
       toggleBlockLabel,
     ]
@@ -1133,8 +1132,7 @@ export function FixedToolbar({
       <ToolbarSeparator />
       <TextEditorColorControls editor={editor} />
 
-      {/* Media group */}
-      {workspaceId && onImageUpload && (
+      {onImageUpload && (
         <>
           <ToolbarSeparator />
           <ToolbarButton
@@ -1150,23 +1148,24 @@ export function FixedToolbar({
             onClick={() => fileInputRef.current?.click()}
             disabled={isUploadingImage}
           />
-          <ToolbarButton
-            id="video"
-            icon={
-              isUploadingVideo ? (
-                <Loader2 className="size-4 animate-spin" />
-              ) : (
-                <FileVideo className="size-4" />
-              )
-            }
-            pressed={false}
-            onClick={() => videoInputRef.current?.click()}
-            disabled={isUploadingVideo}
-          />
+          {workspaceId && (
+            <ToolbarButton
+              id="video"
+              icon={
+                isUploadingVideo ? (
+                  <Loader2 className="size-4 animate-spin" />
+                ) : (
+                  <FileVideo className="size-4" />
+                )
+              }
+              pressed={false}
+              onClick={() => videoInputRef.current?.click()}
+              disabled={isUploadingVideo}
+            />
+          )}
         </>
       )}
 
-      {/* Convert to task */}
       {onConvertToTask && (
         <>
           <ToolbarSeparator />

package/src/hooks/__tests__/collaboration-awareness.test.ts

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import * as Y from 'yjs';
+import SupabaseProvider from '../supabase-provider';
+
+vi.mock('@tuturuuu/internal-api/realtime', () => ({
+  createRealtimeClient: () => {
+    const channel = {
+      on: () => channel,
+      subscribe: () => channel,
+      send: vi.fn(),
+    };
+    return { channel: () => channel, removeChannel: vi.fn() };
+  },
+}));
+afterEach(() => vi.useRealTimers());
+describe('collaboration cursor batching', () => {
+  it('merges all changed client IDs and flushes during continuous updates', async () => {
+    vi.useFakeTimers();
+    const doc = new Y.Doc();
+    const provider = new SupabaseProvider(
+      doc,
+      {} as ConstructorParameters<typeof SupabaseProvider>[1],
+      {
+        channel: 'task-editor-fixture',
+        id: 'fixture',
+        tableName: 'tasks',
+        columnName: 'description_yjs_state',
+        loadState: async () => null,
+        saveState: async () => true,
+        resyncInterval: false,
+      }
+    );
+    const a = new Y.Doc();
+    const b = new Y.Doc();
+    const first = new awarenessProtocol.Awareness(a);
+    const second = new awarenessProtocol.Awareness(b);
+    first.setLocalState({ user: { id: 'a' }, cursor: 1 });
+    second.setLocalState({ user: { id: 'b' }, cursor: 2 });
+    const sent = vi.fn();
+    provider.on('awareness', sent);
+    awarenessProtocol.applyAwarenessUpdate(
+      provider.awareness,
+      awarenessProtocol.encodeAwarenessUpdate(first, [a.clientID]),
+      'local-fixture'
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    awarenessProtocol.applyAwarenessUpdate(
+      provider.awareness,
+      awarenessProtocol.encodeAwarenessUpdate(second, [b.clientID]),
+      'local-fixture'
+    );
+    await vi.advanceTimersByTimeAsync(50);
+    expect(sent).toHaveBeenCalledOnce();
+    const receiverDoc = new Y.Doc();
+    const receiver = new awarenessProtocol.Awareness(receiverDoc);
+    awarenessProtocol.applyAwarenessUpdate(
+      receiver,
+      sent.mock.calls[0]![0],
+      'fixture'
+    );
+    expect(receiver.getStates().get(a.clientID)).toMatchObject({ cursor: 1 });
+    expect(receiver.getStates().get(b.clientID)).toMatchObject({ cursor: 2 });
+    provider.destroy();
+    provider.awareness.destroy();
+    first.destroy();
+    second.destroy();
+    receiver.destroy();
+    for (const d of [doc, a, b, receiverDoc]) d.destroy();
+  });
+  it('does not rebroadcast peer awareness back to the room', async () => {
+    vi.useFakeTimers();
+    const doc = new Y.Doc();
+    const peerDoc = new Y.Doc();
+    const provider = new SupabaseProvider(
+      doc,
+      {} as ConstructorParameters<typeof SupabaseProvider>[1],
+      {
+        channel: 'task-editor-fixture',
+        id: 'fixture',
+        tableName: 'tasks',
+        columnName: 'description_yjs_state',
+        loadState: async () => null,
+        saveState: async () => true,
+        resyncInterval: false,
+      }
+    );
+    const peer = new awarenessProtocol.Awareness(peerDoc);
+    peer.setLocalState({ cursor: 4 });
+    const sent = vi.fn();
+    provider.on('awareness', sent);
+    provider.onAwareness(
+      awarenessProtocol.encodeAwarenessUpdate(peer, [peerDoc.clientID])
+    );
+    await vi.advanceTimersByTimeAsync(200);
+    expect(sent).not.toHaveBeenCalled();
+    expect(provider.awareness.getStates().get(peerDoc.clientID)).toMatchObject({
+      cursor: 4,
+    });
+    provider.destroy();
+    provider.awareness.destroy();
+    peer.destroy();
+    doc.destroy();
+    peerDoc.destroy();
+  });
+});

package/src/hooks/__tests__/supabase-provider.test.ts

@@ -5,6 +5,14 @@ import SupabaseProvider, {
   SUPABASE_PROVIDER_SYNC_ORIGIN,
 } from '../supabase-provider';
 
+const realtimeMock = vi.hoisted(() => ({ channel: null as unknown }));
+vi.mock('@tuturuuu/internal-api/realtime', () => ({
+  createRealtimeClient: () => ({
+    channel: () => realtimeMock.channel,
+    removeChannel: vi.fn(),
+  }),
+}));
+
 function createRealtimeChannel() {
   let subscribeHandler:
     | ((status: string, err?: { message?: string }) => void)
@@ -22,6 +30,7 @@ function createRealtimeChannel() {
     },
   };
 
+  realtimeMock.channel = channel;
   return channel;
 }
 

package/src/hooks/__tests__/use-calendar-readonly.test.tsx

@@ -294,10 +294,15 @@ describe('CalendarProvider Read-Only Mode', () => {
       await createPromise!;
     });
 
+    const optimisticId = calendarMockState.patchVisibleEvents.mock.calls.find(
+      ([, options]) => options?.status === 'creating'
+    )?.[0]?.[0]?.id;
+    expect(optimisticId).toMatch(/^optimistic[0-9a-f]{32}$/);
+
     expect(calendarMockState.patchVisibleEvents).toHaveBeenLastCalledWith(
       [serverEvent],
       expect.objectContaining({
-        clearIds: [expect.stringMatching(/^optimistic-/)],
+        clearIds: [optimisticId],
       })
     );
   });
@@ -322,10 +327,15 @@ describe('CalendarProvider Read-Only Mode', () => {
       ).rejects.toThrow('create failed');
     });
 
+    const optimisticId = calendarMockState.patchVisibleEvents.mock.calls.find(
+      ([, options]) => options?.status === 'creating'
+    )?.[0]?.[0]?.id;
+    expect(optimisticId).toMatch(/^optimistic[0-9a-f]{32}$/);
+
     expect(calendarMockState.patchVisibleEvents).toHaveBeenLastCalledWith(
       [],
       expect.objectContaining({
-        clearIds: [expect.stringMatching(/^optimistic-/)],
+        clearIds: [optimisticId],
       })
     );
   });

package/src/hooks/__tests__/use-notifications-subscription.test.tsx

@@ -11,7 +11,7 @@ import {
 } from '../use-notifications';
 
 const createRealtimeClient = vi.hoisted(() => vi.fn());
-vi.mock('@tuturuuu/supabase/next/realtime-browser', () => ({
+vi.mock('@tuturuuu/internal-api/realtime', () => ({
   createRealtimeClient,
 }));
 
@@ -31,6 +31,10 @@ describe('notification API refresh subscriptions', () => {
       configurable: true,
       value: 'visible',
     });
+    Object.defineProperty(navigator, 'onLine', {
+      configurable: true,
+      value: true,
+    });
   });
   afterEach(() => {
     __resetNotificationSubscriptionRegistryForTests();
@@ -51,6 +55,32 @@ describe('notification API refresh subscriptions', () => {
     client.clear();
   });
 
+  it('makes 30 shared refreshes per visible hour, pauses offline, and refreshes on reconnect', () => {
+    const client = new QueryClient();
+    const invalidate = vi.spyOn(client, 'invalidateQueries');
+    const hook = renderHook(() => useNotificationSubscription(null, 'user-1'), {
+      wrapper: wrapper(client),
+    });
+    act(() => vi.advanceTimersByTime(60 * 60_000));
+    expect(invalidate).toHaveBeenCalledTimes(30);
+    Object.defineProperty(navigator, 'onLine', {
+      configurable: true,
+      value: false,
+    });
+    act(() => vi.advanceTimersByTime(60 * 60_000));
+    expect(invalidate).toHaveBeenCalledTimes(30);
+    Object.defineProperty(navigator, 'onLine', {
+      configurable: true,
+      value: true,
+    });
+    act(() => window.dispatchEvent(new Event('online')));
+    expect(invalidate).toHaveBeenCalledTimes(31);
+    hook.unmount();
+    act(() => window.dispatchEvent(new Event('online')));
+    expect(invalidate).toHaveBeenCalledTimes(31);
+    client.clear();
+  });
+
   it('shares one refresh per user and query client without opening a denied realtime channel', () => {
     const client = new QueryClient();
     const invalidate = vi.spyOn(client, 'invalidateQueries');

package/src/hooks/__tests__/use-visible-workspaces.test.tsx

@@ -0,0 +1,76 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { useVisibleWorkspaces } from '../use-visible-workspaces';
+import { WorkspaceVisibilityProvider } from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ list: vi.fn(), hidden: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/workspaces', () => ({
+  listWorkspaces: mocks.list,
+}));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.hidden,
+  updateCurrentUserHiddenWorkspace: vi.fn(),
+}));
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.list.mockResolvedValue([{ id: 'visible' }, { id: 'hidden' }]);
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['hidden'] });
+});
+function fixture() {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false, retryDelay: 0 } },
+  });
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId="A">
+        {children}
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  return { client, wrapper };
+}
+it('retains an explicit zero bound and only exposes known visible choices', async () => {
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(true, 0), {
+    wrapper,
+  });
+  await waitFor(() => expect(result.current.data).toEqual([{ id: 'visible' }]));
+  expect(mocks.list).toHaveBeenCalledWith({ limit: 0 });
+  expect(client.getQueryData(['workspace-ui-list', 'A', 0])).toHaveLength(2);
+});
+it('settled private discovery failure is an error rather than permanent loading', async () => {
+  mocks.hidden.mockRejectedValue(new Error('offline'));
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(), { wrapper });
+  await waitFor(() =>
+    expect(client.getQueryState(['workspace-hidden', 'A'])?.status).toBe(
+      'error'
+    )
+  );
+  await waitFor(() => expect(result.current.isLoading).toBe(false));
+  expect(result.current.isError).toBe(true);
+  expect(result.current.error?.message).toBe('offline');
+  expect(result.current.data).toBeUndefined();
+});
+
+it('distinguishes an absent personal workspace from one excluded by Hidden preferences', async () => {
+  mocks.list.mockResolvedValue([{ id: 'team', personal: false }]);
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(), { wrapper });
+  await waitFor(() =>
+    expect(result.current.personalWorkspaceMissing).toBe(true)
+  );
+  mocks.list.mockResolvedValue([
+    { id: 'team', personal: false },
+    { id: 'personal', personal: true },
+  ]);
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['personal'] });
+  await result.current.refetch();
+  await waitFor(() =>
+    expect(result.current.data).toEqual([{ id: 'team', personal: false }])
+  );
+  expect(result.current.personalWorkspaceMissing).toBe(false);
+  expect(client.getQueryData(['workspace-ui-list', 'A'])).toHaveLength(2);
+});

package/src/hooks/__tests__/use-workspace-presence.test.tsx

@@ -3,7 +3,7 @@
  */
 
 import { act, renderHook, waitFor } from '@testing-library/react';
-import type { RealtimePresenceState } from '@tuturuuu/supabase/next/realtime';
+import type { RealtimePresenceState } from '@tuturuuu/internal-api/realtime';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   type UseWorkspacePresenceResult,
@@ -16,8 +16,8 @@ const { createClientMock, getCurrentUserProfileMock } = vi.hoisted(() => ({
   getCurrentUserProfileMock: vi.fn(),
 }));
 
-vi.mock('@tuturuuu/supabase/next/client', () => ({
-  createClient: createClientMock,
+vi.mock('@tuturuuu/internal-api/realtime', () => ({
+  createRealtimeClient: createClientMock,
 }));
 
 vi.mock('@tuturuuu/internal-api/users', () => ({

package/src/hooks/__tests__/use-workspace-visibility.test.tsx

@@ -0,0 +1,155 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  useWorkspaceVisibility,
+  WorkspaceVisibilityProvider,
+} from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ get: vi.fn(), put: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.get,
+  updateCurrentUserHiddenWorkspace: mocks.put,
+}));
+function deferred<T>() {
+  let resolve!: (v: T) => void;
+  let reject!: (e: Error) => void;
+  const promise = new Promise<T>((a, b) => {
+    resolve = a;
+    reject = b;
+  });
+  return { promise, resolve, reject };
+}
+function setup(
+  actor = 'A',
+  client = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  })
+) {
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId={actor}>
+        {children}
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  return { ...renderHook(() => useWorkspaceVisibility(), { wrapper }), client };
+}
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.get.mockResolvedValue({ hiddenWorkspaceIds: [] });
+  mocks.put.mockResolvedValue({});
+});
+describe('private owner-scoped workspace visibility', () => {
+  it('optimistically hides and rolls back only the failed workspace', async () => {
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.hiddenIds).toEqual(['ws-1'])
+    );
+    await act(async () => {
+      write.reject(new Error('offline'));
+      await expect(operation).rejects.toThrow('offline');
+    });
+    expect(hook.result.current.hiddenIds).toEqual([]);
+    expect(hook.result.current.updateError).not.toBeNull();
+    expect(mocks.put).toHaveBeenCalledWith('ws-1', true, 'A');
+    await act(async () => {
+      await hook.result.current.refetch();
+    });
+    expect(hook.result.current.updateError).toBeNull();
+  });
+  it('a stale refresh cannot replace optimistic state', async () => {
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    const read = deferred<{ hiddenWorkspaceIds: string[] }>();
+    mocks.get
+      .mockImplementationOnce(() => read.promise)
+      .mockResolvedValue({ hiddenWorkspaceIds: ['ws-1'] });
+    act(() => {
+      void hook.result.current.refetch();
+    });
+    await act(async () => {
+      await hook.result.current.setHidden('ws-1', true);
+    });
+    await act(async () => {
+      read.resolve({ hiddenWorkspaceIds: [] });
+    });
+    expect(hook.result.current.hiddenIds).toEqual(['ws-1']);
+  });
+  it('suppresses duplicate writes for the same pending workspace', async () => {
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.pending.has('ws-1')).toBe(true)
+    );
+    await act(async () => {
+      await hook.result.current.setHidden('ws-1', true);
+    });
+    expect(mocks.put).toHaveBeenCalledTimes(1);
+    await act(async () => {
+      write.resolve({});
+      await operation;
+    });
+  });
+  it('removes private owner caches on logout and ignores late response', async () => {
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.hiddenIds).toEqual(['ws-1'])
+    );
+    hook.unmount();
+    write.resolve({});
+    await operation;
+    expect(hook.client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+    expect(hook.client.getQueryData(['workspace-hidden', 'B'])).toBeUndefined();
+  });
+  it('two actors use independent hidden cache keys', async () => {
+    mocks.get.mockImplementation(async (actor: string) => ({
+      hiddenWorkspaceIds: actor === 'A' ? ['ws-1'] : [],
+    }));
+    const client = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    });
+    const a = setup('A', client);
+    const b = setup('B', client);
+    await waitFor(() => expect(a.result.current.hiddenIds).toEqual(['ws-1']));
+    await waitFor(() => expect(b.result.current.known).toBe(true));
+    expect(b.result.current.hiddenIds).toEqual([]);
+  });
+});
+
+it('settles a refetch safely after logout without returning private old-actor data', async () => {
+  const hook = setup();
+  await waitFor(() => expect(hook.result.current.known).toBe(true));
+  const read = deferred<{ hiddenWorkspaceIds: string[] }>();
+  mocks.get.mockReturnValue(read.promise);
+  let operation!: ReturnType<typeof hook.result.current.refetch>;
+  act(() => {
+    operation = hook.result.current.refetch();
+  });
+  await waitFor(() => expect(mocks.get).toHaveBeenCalledTimes(2));
+  hook.unmount();
+  read.resolve({ hiddenWorkspaceIds: ['old-private'] });
+  await expect(operation).resolves.toBeNull();
+  expect(hook.client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+});