@tuturuuu/ui 0.37.1 → 0.38.0

package/src/hooks/__tests__/use-yjs-collaboration.test.tsx

@@ -0,0 +1,108 @@
+import { act, renderHook } from '@testing-library/react';
+import { type ReactNode, StrictMode } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useYjsCollaboration } from '../use-yjs-collaboration';
+
+const instances = vi.hoisted(
+  () =>
+    [] as {
+      id: number;
+      destroyed: boolean;
+      emit: (event: string, value: unknown) => void;
+    }[]
+);
+vi.mock('@tuturuuu/supabase/next/client', () => ({ createClient: () => ({}) }));
+vi.mock('@tuturuuu/ui/hooks/supabase-provider', () => ({
+  default: class {
+    id: number;
+    destroyed = false;
+    awareness: { destroy: () => void };
+    private listeners = new Map<string, (value: unknown) => void>();
+    constructor(
+      private doc: { clientID: number; destroy: () => void },
+      _client: unknown,
+      config: { awareness: { destroy: () => void } }
+    ) {
+      this.id = doc.clientID;
+      this.awareness = config.awareness;
+      instances.push(this);
+    }
+    on(event: string, callback: (value: unknown) => void) {
+      this.listeners.set(event, callback);
+    }
+    emit(event: string, value: unknown) {
+      this.listeners.get(event)?.(value);
+    }
+    destroy() {
+      this.destroyed = true;
+      this.awareness.destroy();
+      this.doc.destroy();
+    }
+  },
+}));
+const user = { id: 'actor', name: 'Ada', color: '#123456' };
+const config = {
+  channel: 'task-editor-one',
+  tableName: 'tasks',
+  columnName: 'description_yjs_state',
+  id: 'one',
+  user,
+};
+const wrapper = ({ children }: { children: ReactNode }) => (
+  <StrictMode>{children}</StrictMode>
+);
+describe('collaboration hook lifecycle', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    instances.length = 0;
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+  it('does not start awareness before authentication and reuses StrictMode providers', async () => {
+    const { result, rerender, unmount } = renderHook(
+      (actor) => useYjsCollaboration({ ...config, user: actor }),
+      { wrapper, initialProps: null as typeof user | null }
+    );
+    expect(result.current.doc).toBeNull();
+    expect(result.current.awareness).toBeNull();
+    expect(instances).toHaveLength(0);
+    rerender(user);
+    expect(instances).toHaveLength(1);
+    const provider = result.current.provider;
+    expect(provider).not.toBeNull();
+    rerender({ ...user, name: 'Ada updated' });
+    expect(result.current.provider).toBe(provider);
+    expect(result.current.awareness?.getLocalState()?.user.name).toBe(
+      'Ada updated'
+    );
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+    expect(instances[0]?.destroyed).toBe(true);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('isolates account/resource switches and ignores late callbacks from old providers', async () => {
+    const { result, rerender, unmount } = renderHook(
+      (id) =>
+        useYjsCollaboration({ ...config, id, channel: `task-editor-${id}` }),
+      { wrapper, initialProps: 'one' }
+    );
+    const first = instances[0]!;
+    const firstDoc = result.current.doc;
+    rerender('two');
+    expect(instances).toHaveLength(2);
+    expect(first.destroyed).toBe(true);
+    expect(result.current.doc).not.toBe(firstDoc);
+    const second = instances[1]!;
+    act(() => second.emit('status', [{ status: 'connected' }]));
+    expect(result.current.connected).toBe(true);
+    act(() => first.emit('disconnect', []));
+    expect(result.current.connected).toBe(true);
+    act(() => first.emit('synced', [true]));
+    expect(result.current.synced).toBe(false);
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+    expect(second.destroyed).toBe(true);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});

package/src/hooks/__tests__/workspace-actor-lifetime.test.tsx

@@ -0,0 +1,103 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { useWorkspaceUser } from '../use-workspace-user';
+import {
+  useWorkspaceVisibility,
+  WorkspaceVisibilityProvider,
+} from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ hidden: vi.fn(), profile: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.hidden,
+  getCurrentUserProfile: mocks.profile,
+  updateCurrentUserHiddenWorkspace: vi.fn(),
+}));
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['private'] });
+  mocks.profile.mockResolvedValue({ id: 'A' });
+});
+function Probe() {
+  const hidden = useWorkspaceVisibility();
+  const user = useWorkspaceUser();
+  return (
+    <output>
+      {JSON.stringify({
+        known: hidden.known,
+        ids: hidden.hiddenIds,
+        user: user.data?.id,
+      })}
+    </output>
+  );
+}
+function fixture() {
+  return new QueryClient({
+    defaultOptions: { queries: { retry: false, retryDelay: 0 } },
+  });
+}
+it('retains the root owner cache across same-actor route unmount and remount', async () => {
+  const client = fixture();
+  function Tree({ route }: { route: boolean }) {
+    return (
+      <QueryClientProvider client={client}>
+        <WorkspaceVisibilityProvider actorId="A">
+          {route && (
+            <WorkspaceVisibilityProvider actorId="A">
+              <Probe />
+            </WorkspaceVisibilityProvider>
+          )}
+        </WorkspaceVisibilityProvider>
+      </QueryClientProvider>
+    );
+  }
+  const tree = render(<Tree route />);
+  await waitFor(() =>
+    expect(screen.getByRole('status').textContent).toContain('"known":true')
+  );
+  await waitFor(() =>
+    expect(client.getQueryData(['workspace-user', 'A'])).toMatchObject({
+      id: 'A',
+    })
+  );
+  tree.rerender(<Tree route={false} />);
+  expect(client.getQueryData(['workspace-hidden', 'A'])).toEqual(['private']);
+  tree.rerender(<Tree route />);
+  await waitFor(() =>
+    expect(screen.getByRole('status').textContent).toContain('private')
+  );
+  expect(mocks.hidden).toHaveBeenCalledTimes(1);
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(client.getQueryData(['workspace-user'])).toBeUndefined();
+  tree.unmount();
+  expect(client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+  expect(client.getQueryData(['workspace-user', 'A'])).toBeUndefined();
+});
+it('does not read profiles or private preferences without verified identity', async () => {
+  const client = fixture();
+  render(
+    <QueryClientProvider client={client}>
+      <Probe />
+    </QueryClientProvider>
+  );
+  await act(async () => {});
+  expect(mocks.profile).not.toHaveBeenCalled();
+  expect(mocks.hidden).not.toHaveBeenCalled();
+  expect(screen.getByRole('status').textContent).toContain('"known":false');
+});
+it('fails a mismatched route actor closed under a verified root', async () => {
+  const client = fixture();
+  render(
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId="B">
+        <WorkspaceVisibilityProvider actorId="A">
+          <Probe />
+        </WorkspaceVisibilityProvider>
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  await act(async () => {});
+  expect(mocks.profile).not.toHaveBeenCalled();
+  expect(mocks.hidden).not.toHaveBeenCalled();
+  expect(screen.getByRole('status').textContent).toContain('"known":false');
+});

package/src/hooks/calendar-creation-request.test.ts

@@ -0,0 +1,62 @@
+import { validate, version } from 'uuid';
+import { expect, it } from 'vitest';
+import {
+  createCalendarCreationRequests,
+  createOptimisticEventId,
+  newCalendarCreationRequestId,
+} from './calendar-creation-request';
+
+it('keeps explicit draft IDs on lost responses and separates manual and AI drafts', () => {
+  const ids = createCalendarCreationRequests();
+  const manual = newCalendarCreationRequestId();
+  const ai = [newCalendarCreationRequestId(), newCalendarCreationRequestId()];
+  expect(new Set([manual, ...ai]).size).toBe(3);
+  for (const [index, id] of [manual, ...ai].entries()) {
+    expect(validate(id)).toBe(true);
+    expect(version(id)).toBe(7);
+    const payload = {
+      title: `draft ${index}`,
+      source: { provider: 'google', connectionId: 'owned' },
+    };
+    expect(ids.forAttempt(payload, id)).toBe(id);
+    expect(ids.forAttempt({ ...payload }, id)).toBe(id);
+  }
+});
+it('rejects changed intent for an uncertain draft before dispatch', () => {
+  const ids = createCalendarCreationRequests();
+  const id = newCalendarCreationRequestId();
+  ids.forAttempt({ title: 'Original' }, id);
+  expect(() => ids.forAttempt({ title: 'Edited' }, id)).toThrow(
+    'draft changed'
+  );
+  expect(
+    ids.forAttempt({ title: 'Edited' }, newCalendarCreationRequestId())
+  ).not.toBe(id);
+});
+it('allocates a new independent intent per call unless the caller supplies a retry ID', () => {
+  const ids = createCalendarCreationRequests();
+  const event = { title: 'Same independent contents' };
+  expect(ids.forAttempt(event)).not.toBe(ids.forAttempt(event));
+});
+
+it('accepts the same serialized intent when object key order changes', () => {
+  const ids = createCalendarCreationRequests();
+  const id = newCalendarCreationRequestId();
+  ids.forAttempt(
+    { title: 'Same', source: { provider: 'google', connectionId: 'owned' } },
+    id
+  );
+  expect(
+    ids.forAttempt(
+      { source: { connectionId: 'owned', provider: 'google' }, title: 'Same' },
+      id
+    )
+  ).toBe(id);
+});
+
+it('keeps optimistic identifiers separate from multi-day segment delimiters', () => {
+  const id = createOptimisticEventId();
+  expect(id).toMatch(/^optimistic[a-zA-Z0-9]+$/);
+  expect(id).not.toContain('-');
+  expect(createOptimisticEventId()).not.toBe(id);
+});

package/src/hooks/calendar-creation-request.ts

@@ -0,0 +1,34 @@
+import { v7 } from 'uuid';
+
+export const newCalendarCreationRequestId = () => v7();
+/** Explicit draft IDs survive retries. Independent calls receive separate IDs;
+ * changed intent after an uncertain response must start an explicit new draft. */
+export function createCalendarCreationRequests() {
+  const intents = new Map<string, string>();
+  return {
+    forAttempt(event: object, requestId?: string) {
+      const id = requestId ?? v7();
+      const intent = JSON.stringify(event, (_key, value) =>
+        value && typeof value === 'object' && !Array.isArray(value)
+          ? Object.fromEntries(
+              Object.keys(value)
+                .sort()
+                .map((key) => [key, value[key]])
+            )
+          : value
+      );
+      const previous = intents.get(id);
+      if (previous !== undefined && previous !== intent)
+        throw new Error(
+          'This calendar draft changed after submission; recover it before starting a new draft'
+        );
+      if (requestId) intents.set(id, intent);
+      return id;
+    },
+  };
+}
+export const createOptimisticEventId = () => {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function')
+    return `optimistic${crypto.randomUUID().replaceAll('-', '')}`;
+  return `optimistic${Date.now()}${Math.random().toString(36).slice(2)}`;
+};

package/src/hooks/calendar-event-write-payload.ts

@@ -0,0 +1,24 @@
+import type { WorkspaceCalendarEventUpdatePayload } from '@tuturuuu/internal-api';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+
+export function calendarEventUpdatePayload(
+  input: Partial<CalendarEvent>
+): WorkspaceCalendarEventUpdatePayload {
+  const payload: WorkspaceCalendarEventUpdatePayload = {};
+  for (const field of [
+    'title',
+    'description',
+    'location',
+    'start_at',
+    'end_at',
+    'locked',
+    'source',
+    'providerColor',
+  ] as const) {
+    if (input[field] !== undefined)
+      Object.assign(payload, { [field]: input[field] });
+  }
+  if (!input.providerColor && input.color !== undefined)
+    payload.color = input.color;
+  return payload;
+}

package/src/hooks/notification-subscription.ts

@@ -1,7 +1,7 @@
 import { type QueryClient, useQueryClient } from '@tanstack/react-query';
 import { useEffect } from 'react';
 
-export const NOTIFICATION_REFRESH_INTERVAL_MS = 30_000;
+export const NOTIFICATION_REFRESH_INTERVAL_MS = 120_000;
 
 interface NotificationSubscriptionEntry {
   queryClients: Map<QueryClient, number>;
@@ -12,7 +12,8 @@ interface NotificationSubscriptionEntry {
 const registry = new Map<string, NotificationSubscriptionEntry>();
 
 function invalidateVisibleNotifications(entry: NotificationSubscriptionEntry) {
-  if (document.visibilityState === 'hidden') return;
+  if (document.visibilityState === 'hidden' || navigator.onLine === false)
+    return;
   for (const queryClient of entry.queryClients.keys()) {
     // Only active queries refetch; closed inboxes remain lazy.
     void queryClient.invalidateQueries({ queryKey: ['notifications'] });
@@ -22,6 +23,7 @@ function invalidateVisibleNotifications(entry: NotificationSubscriptionEntry) {
 function stopEntry(entry: NotificationSubscriptionEntry) {
   clearInterval(entry.interval);
   document.removeEventListener('visibilitychange', entry.onVisibilityChange);
+  window.removeEventListener('online', entry.onVisibilityChange);
 }
 
 /**
@@ -50,6 +52,7 @@ export function useNotificationSubscription(
       };
       registry.set(userId, entry);
       document.addEventListener('visibilitychange', refresh);
+      window.addEventListener('online', refresh);
     }
     entry.queryClients.set(
       queryClient,