@tuturuuu/ui 0.38.0 → 0.39.0

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

@@ -35,13 +35,13 @@ import { toast } from '@tuturuuu/ui/sonner';
 import { cn } from '@tuturuuu/utils/format';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { TextEditorColorControls } from './color-controls';
-import { type EditorCopyLabels, EditorCopyMenu } from './copy-menu';
+import type { EditorCopyLabels } from './copy-menu';
+import { FixedToolbarContents } from './fixed-toolbar-contents';
 import {
   MAX_IMAGE_SIZE,
   MAX_VIDEO_SIZE,
   StorageQuotaError,
 } from './media-utils';
-import { TOOLBAR_GROUPS } from './toolbar-config';
 import { ToolbarButton, ToolbarSeparator } from './toolbar-controls';
 
 type LinkEditorContext = 'bubble' | 'popover' | null;
@@ -842,6 +842,7 @@ export function ToolBar({
 }
 
 interface FixedToolbarProps {
+  toolsLabel?: string;
   editor: Editor | null;
   leadingContent?: React.ReactNode;
   workspaceId?: string;
@@ -853,6 +854,7 @@ interface FixedToolbarProps {
   copyLabels?: EditorCopyLabels;
 }
 export function FixedToolbar({
+  toolsLabel,
   editor,
   leadingContent,
   workspaceId,
@@ -1108,78 +1110,20 @@ export function FixedToolbar({
           <ToolbarSeparator />
         </>
       ) : null}
-      {/* Grouped formatting options with separators */}
-      {TOOLBAR_GROUPS.map((group, gi) => (
-        <div key={gi} className="contents">
-          {gi > 0 && <ToolbarSeparator />}
-          {group.map((key) => {
-            const opt = formattingOptions.get(key);
-            if (!opt) return null;
-            return (
-              <ToolbarButton
-                key={key}
-                id={key}
-                label={key === 'toggle-block' ? toggleBlockLabel : undefined}
-                icon={opt.icon}
-                pressed={opt.pressed}
-                onClick={opt.onClick}
-              />
-            );
-          })}
-        </div>
-      ))}
-
-      <ToolbarSeparator />
-      <TextEditorColorControls editor={editor} />
-
-      {onImageUpload && (
-        <>
-          <ToolbarSeparator />
-          <ToolbarButton
-            id="image"
-            icon={
-              isUploadingImage ? (
-                <Loader2 className="size-4 animate-spin" />
-              ) : (
-                <ImageIcon className="size-4" />
-              )
-            }
-            pressed={false}
-            onClick={() => fileInputRef.current?.click()}
-            disabled={isUploadingImage}
-          />
-          {workspaceId && (
-            <ToolbarButton
-              id="video"
-              icon={
-                isUploadingVideo ? (
-                  <Loader2 className="size-4 animate-spin" />
-                ) : (
-                  <FileVideo className="size-4" />
-                )
-              }
-              pressed={false}
-              onClick={() => videoInputRef.current?.click()}
-              disabled={isUploadingVideo}
-            />
-          )}
-        </>
-      )}
-
-      {onConvertToTask && (
-        <>
-          <ToolbarSeparator />
-          <ToolbarButton
-            id="convert-to-task"
-            icon={<CirclePlus className="size-4" />}
-            pressed={false}
-            onClick={onConvertToTask}
-          />
-        </>
-      )}
-
-      <ToolbarSeparator />
-      <EditorCopyMenu editor={editor} labels={copyLabels} />
+      <FixedToolbarContents
+        editor={editor}
+        options={formattingOptions}
+        toolsLabel={toolsLabel}
+        toggleBlockLabel={toggleBlockLabel}
+        copyLabels={copyLabels}
+        imageUpload={!!onImageUpload}
+        videoUpload={!!workspaceId}
+        uploadingImage={isUploadingImage}
+        uploadingVideo={isUploadingVideo}
+        onImage={() => fileInputRef.current?.click()}
+        onVideo={() => videoInputRef.current?.click()}
+        onConvertToTask={onConvertToTask}
+      />
     </div>
   );
 }

package/src/hooks/__tests__/calendar-event-write-payload-readonly.test.ts

@@ -0,0 +1,40 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import { describe, expect, it } from 'vitest';
+import { assertOrdinaryCalendarEvent } from '../calendar-event-write-payload';
+
+const event = {
+  id: 'instance',
+  start_at: '2026-10-06T09:00:00Z',
+  end_at: '2026-10-06T10:00:00Z',
+  _originalId: 'original',
+  scheduling_metadata: {
+    provider_recurrence: {
+      state: 'unsupported',
+      provider: 'google',
+      master_id: 'master',
+    },
+  },
+} as CalendarEvent;
+describe('provider readonly ordinary mutation fence', () => {
+  it.each(['instance', 'original'])(
+    'blocks updates/deletes by %s identity even if user unlocks the local event',
+    (id) =>
+      expect(() =>
+        assertOrdinaryCalendarEvent([{ ...event, locked: false }], id)
+      ).toThrow('read only')
+  );
+  it('permits an ordinary independently locked event', () =>
+    expect(() =>
+      assertOrdinaryCalendarEvent(
+        [{ id: 'ordinary', locked: true } as CalendarEvent],
+        'ordinary'
+      )
+    ).not.toThrow());
+  it('retains the scoped native occurrence fence', () =>
+    expect(() =>
+      assertOrdinaryCalendarEvent(
+        [{ id: 'native', seriesId: 'series' } as CalendarEvent],
+        'native'
+      )
+    ).toThrow('explicit series edit scope'));
+});

package/src/hooks/__tests__/native-calendar-mutation-guard.test.ts

@@ -0,0 +1,45 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import { describe, expect, it } from 'vitest';
+import {
+  assertOrdinaryCalendarEvent,
+  calendarEventByIdentity,
+  cleanCalendarEventUpdates,
+} from '../calendar-event-write-payload';
+
+const virtual: CalendarEvent = {
+  id: '123e4567-e89b-42d3-a456-426614174000',
+  seriesId: 'series',
+  originalStartLocal: '2026-10-05T09:00:00',
+  start_at: '2026-10-05T09:00:00Z',
+  end_at: '2026-10-05T10:00:00Z',
+};
+describe('native virtual mutation fence', () => {
+  it('resolves full UUID identities without truncating at the first dash', () => {
+    expect(calendarEventByIdentity([virtual], virtual.id)).toBe(virtual);
+  });
+  it('rejects ordinary update/delete/drag identity paths for virtual rows and split rows', () => {
+    expect(() => assertOrdinaryCalendarEvent([virtual], virtual.id)).toThrow();
+    expect(() =>
+      assertOrdinaryCalendarEvent(
+        [{ ...virtual, id: 'split', _originalId: virtual.id }],
+        virtual.id
+      )
+    ).toThrow();
+  });
+  it('preserves ordinary event mutation behavior', () => {
+    expect(() =>
+      assertOrdinaryCalendarEvent(
+        [{ ...virtual, seriesId: undefined }],
+        virtual.id
+      )
+    ).not.toThrow();
+    expect(
+      cleanCalendarEventUpdates({
+        title: 'Title',
+        seriesId: 'injected',
+        originalStartLocal: 'injected',
+        start_at: '2026-10-05T12:00:00Z',
+      })
+    ).toEqual({ title: 'Title', start_at: '2026-10-05T12:00:00Z' });
+  });
+});

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

@@ -66,9 +66,7 @@ describe('SupabaseProvider', () => {
 
     channel.trigger('SUBSCRIBED');
 
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(provider.connected).toBe(true);
+    await waitFor(() => expect(provider.connected).toBe(true));
     expect(provider.synced).toBe(true);
 
     doc.getMap('prosemirror').set('text', 'hello');
@@ -165,8 +163,7 @@ describe('SupabaseProvider', () => {
     try {
       channel.trigger('SUBSCRIBED');
 
-      await Promise.resolve();
-      await Promise.resolve();
+      await vi.advanceTimersByTimeAsync(0);
       expect(provider.connected).toBe(true);
 
       const sendsBefore = channel.send.mock.calls.length;
@@ -223,8 +220,7 @@ describe('SupabaseProvider', () => {
     try {
       channel.trigger('SUBSCRIBED');
 
-      await Promise.resolve();
-      await Promise.resolve();
+      await vi.advanceTimersByTimeAsync(0);
       expect(provider.connected).toBe(true);
 
       const sendsBefore = channel.send.mock.calls.length;
@@ -353,3 +349,101 @@ describe('SupabaseProvider', () => {
     provider.destroy();
   });
 });
+
+describe('durable hydration without peer transport', () => {
+  it('loads saved content even when the channel never subscribes', async () => {
+    createRealtimeChannel();
+    const saved = new Y.Doc();
+    saved.getText('description').insert(0, 'saved text');
+    const doc = new Y.Doc();
+    const provider = new SupabaseProvider(doc, {} as any, {
+      channel: 'task-editor-offline',
+      tableName: 'tasks',
+      columnName: 'state',
+      id: 'offline',
+      loadState: async () => Array.from(Y.encodeStateAsUpdate(saved)),
+      resyncInterval: false,
+    });
+    await waitFor(() => expect(provider.hydrated).toBe(true));
+    expect(doc.getText('description').toString()).toBe('saved text');
+    expect(provider.connected).toBe(false);
+    expect(provider.synced).toBe(false);
+    provider.destroy();
+    saved.destroy();
+  });
+
+  it('coalesces startup and connection loads and ignores disconnect during hydration', async () => {
+    const channel = createRealtimeChannel();
+    let finish!: (state: number[] | null) => void;
+    const loadState = vi.fn(
+      () =>
+        new Promise<number[] | null>((resolve) => {
+          finish = resolve;
+        })
+    );
+    const provider = new SupabaseProvider(new Y.Doc(), {} as any, {
+      channel: 'task-editor-pending',
+      tableName: 'tasks',
+      columnName: 'state',
+      id: 'pending',
+      loadState,
+      resyncInterval: false,
+    });
+    channel.trigger('SUBSCRIBED');
+    channel.trigger('CLOSED');
+    finish(null);
+    await waitFor(() => expect(provider.hydrated).toBe(true));
+    expect(loadState).toHaveBeenCalledTimes(1);
+    expect(provider.connected).toBe(false);
+    provider.destroy();
+  });
+
+  it('does not hydrate a denied read and retries without unhandled rejection', async () => {
+    const channel = createRealtimeChannel();
+    const loadState = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('Access denied'))
+      .mockResolvedValueOnce(null);
+    const provider = new SupabaseProvider(new Y.Doc(), {} as any, {
+      channel: 'task-editor-denied',
+      tableName: 'tasks',
+      columnName: 'state',
+      id: 'denied',
+      loadState,
+      resyncInterval: false,
+    });
+    const report = vi.fn();
+    provider.on('error', report);
+    await waitFor(() => expect(report).toHaveBeenCalledTimes(1));
+    expect(provider.hydrated).toBe(false);
+    channel.trigger('SUBSCRIBED');
+    await waitFor(() => expect(provider.connected).toBe(true));
+    expect(provider.hydrated).toBe(true);
+    provider.destroy();
+  });
+
+  it('ignores a durable read completing after teardown', async () => {
+    createRealtimeChannel();
+    let finish!: (state: number[] | null) => void;
+    const doc = new Y.Doc();
+    const provider = new SupabaseProvider(doc, {} as any, {
+      channel: 'task-editor-old',
+      tableName: 'tasks',
+      columnName: 'state',
+      id: 'old',
+      loadState: () =>
+        new Promise((resolve) => {
+          finish = resolve;
+        }),
+      resyncInterval: false,
+    });
+    const apply = vi.fn();
+    doc.on('update', apply);
+    provider.destroy();
+    finish(null);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(provider.hydrated).toBe(false);
+    expect(apply).not.toHaveBeenCalled();
+  });
+});

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

@@ -530,4 +530,31 @@ describe('CalendarProvider Read-Only Mode', () => {
       baseEvent,
     ]);
   });
+  it('blocks ordinary update/delete/drag writes for native recurrence occurrences', async () => {
+    const occurrence = {
+      ...baseEvent,
+      seriesId: 'series',
+      seriesRevision: 3,
+      originalStartLocal: '2026-06-22T09:00:00',
+    };
+    calendarMockState.events = [occurrence];
+    const { result } = renderHook(() => useCalendar(), {
+      wrapper: createWrapper(),
+    });
+    await expect(
+      result.current.updateEvent(occurrence.id, {
+        start_at: '2026-06-23T09:00:00Z',
+      })
+    ).rejects.toThrow('explicit series edit scope');
+    await expect(result.current.deleteEvent(occurrence.id)).rejects.toThrow(
+      'explicit series edit scope'
+    );
+    expect(
+      internalApiMocks.updateWorkspaceCalendarEvent
+    ).not.toHaveBeenCalled();
+    expect(
+      internalApiMocks.deleteWorkspaceCalendarEvent
+    ).not.toHaveBeenCalled();
+    expect(result.current.isEventReadOnly(occurrence)).toBe(true);
+  });
 });

package/src/hooks/__tests__/use-local-storage.test.tsx

@@ -147,6 +147,48 @@ describe('useLocalStorage', () => {
   });
 
   describe('error handling', () => {
+    it('completes initialization with defaults when getItem is denied', () => {
+      vi.spyOn(window.localStorage, 'getItem').mockImplementation(() => {
+        throw new DOMException('Synthetic denied read', 'SecurityError');
+      });
+      const { result } = renderHook(() =>
+        useLocalStorage('invoice-compact-view', false)
+      );
+      expect(result.current).toEqual([false, expect.any(Function), true]);
+      expect(console.error).toHaveBeenCalledWith(
+        'Unable to read browser preferences.'
+      );
+      act(() => result.current[1](true));
+      expect(result.current[0]).toBe(true);
+    });
+
+    it('completes initialization when the storage getter itself is denied', () => {
+      const storage = window.localStorage;
+      Object.defineProperty(window, 'localStorage', {
+        configurable: true,
+        get() {
+          throw new DOMException('Synthetic denied getter', 'SecurityError');
+        },
+      });
+      try {
+        const { result } = renderHook(() =>
+          useLocalStorage('printAfterCreate', true)
+        );
+        expect(result.current).toEqual([true, expect.any(Function), true]);
+        act(() => result.current[1](false));
+        expect(result.current[0]).toBe(false);
+        expect(console.error).toHaveBeenLastCalledWith(
+          'Unable to save browser preferences.'
+        );
+      } finally {
+        Object.defineProperty(window, 'localStorage', {
+          configurable: true,
+          writable: true,
+          value: storage,
+        });
+      }
+    });
+
     it('should handle invalid JSON in localStorage gracefully', () => {
       window.localStorage.setItem(TEST_KEY, 'invalid-json');
 

package/src/hooks/__tests__/use-native-calendar-occurrences.test.tsx

@@ -0,0 +1,140 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { InternalApiError } from '@tuturuuu/internal-api/client';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mock = vi.hoisted(() => ({
+  list: vi.fn(),
+  actor: { actorId: 'actor', assertActive: vi.fn() },
+}));
+vi.mock('@tuturuuu/internal-api/calendar-series', () => ({
+  listNativeCalendarOccurrences: mock.list,
+}));
+vi.mock('../use-workspace-visibility', () => ({
+  useWorkspaceActor: () => mock.actor,
+}));
+
+import {
+  EMPTY_NATIVE_OCCURRENCES,
+  nativeOccurrencesKey,
+  useNativeCalendarOccurrences,
+  visibleNativeOccurrences,
+} from '../use-native-calendar-occurrences';
+
+const event: CalendarEvent = {
+  id: 'event',
+  seriesId: 'series',
+  start_at: '2026-10-05T09:00:00Z',
+  end_at: '2026-10-05T10:00:00Z',
+};
+const dates = [new Date(2026, 9, 5)];
+function setup() {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return {
+    client,
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={client}>{children}</QueryClientProvider>
+    ),
+  };
+}
+beforeEach(() => {
+  mock.list.mockReset();
+  mock.actor.actorId = 'actor';
+  mock.actor.assertActive.mockReset();
+  mock.list.mockResolvedValue({ data: [event] });
+});
+describe('native occurrence SWR feed', () => {
+  it('uses one stable empty reference before data and for denied/external feeds', () => {
+    expect(visibleNativeOccurrences(undefined, null)).toBe(
+      EMPTY_NATIVE_OCCURRENCES
+    );
+    expect(
+      visibleNativeOccurrences([event], new InternalApiError('denied', 403))
+    ).toBe(EMPTY_NATIVE_OCCURRENCES);
+  });
+  it.each([
+    new TypeError('Failed to fetch'),
+    new InternalApiError('busy', 429),
+    new InternalApiError('failed', 503),
+    new InternalApiError('verify', 403, 'MFA_REQUIRED'),
+  ])('retains authorized rows for recoverable failure %o', (error) => {
+    const data = [event];
+    expect(visibleNativeOccurrences(data, error)).toBe(data);
+  });
+  it('loads the requested workspace range using an actor-scoped key', async () => {
+    const { client, wrapper } = setup();
+    const { result } = renderHook(
+      () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+      { wrapper }
+    );
+    await waitFor(() => expect(result.current.data).toEqual([event]));
+    expect(mock.list).toHaveBeenCalledWith(
+      'ws',
+      { from: '2026-10-05T00:00:00.000Z', to: '2026-10-06T00:00:00.000Z' },
+      expect.objectContaining({ signal: expect.any(AbortSignal) })
+    );
+    expect(client.getQueryCache().getAll()[0]?.queryKey).toContain('actor');
+  });
+  it('retains cached rows while a transient refresh fails', async () => {
+    const { wrapper } = setup();
+    const { result } = renderHook(
+      () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+      { wrapper }
+    );
+    await waitFor(() => expect(result.current.data).toEqual([event]));
+    mock.list.mockRejectedValue(new InternalApiError('busy', 429));
+    await act(async () => {
+      await result.current.refetch();
+    });
+    expect(result.current.data).toEqual([event]);
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+  it.each([401, 403, 404])(
+    'clears retained and durable rows after definitive status %s',
+    async (status) => {
+      const { client, wrapper } = setup();
+      const { result } = renderHook(
+        () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+        { wrapper }
+      );
+      await waitFor(() => expect(result.current.data).toEqual([event]));
+      mock.list.mockRejectedValue(new InternalApiError('denied', status));
+      await act(async () => {
+        await result.current.refetch();
+      });
+      await waitFor(() =>
+        expect(result.current.data).toBe(EMPTY_NATIVE_OCCURRENCES)
+      );
+      expect(
+        client.getQueriesData({ queryKey: nativeOccurrencesKey('ws') })[0]?.[1]
+      ).toEqual([]);
+    }
+  );
+  it('does not read native data for externally supplied calendars or empty dates', () => {
+    const { wrapper } = setup();
+    const { result, rerender } = renderHook(
+      ({ external, range }) =>
+        useNativeCalendarOccurrences('ws', range, 'UTC', external),
+      { wrapper, initialProps: { external: true, range: dates } }
+    );
+    expect(result.current.data).toBe(EMPTY_NATIVE_OCCURRENCES);
+    rerender({ external: false, range: [] });
+    expect(mock.list).not.toHaveBeenCalled();
+  });
+  it('does not carry a previous actor snapshot into another account', async () => {
+    const { wrapper } = setup();
+    const { result, rerender } = renderHook(
+      () => useNativeCalendarOccurrences('ws', dates, 'UTC', false),
+      { wrapper }
+    );
+    await waitFor(() => expect(result.current.data).toEqual([event]));
+    mock.actor.actorId = 'other';
+    mock.list.mockImplementation(() => new Promise(() => {}));
+    rerender();
+    expect(result.current.data).toBe(EMPTY_NATIVE_OCCURRENCES);
+  });
+});

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

@@ -16,6 +16,7 @@ vi.mock('@tuturuuu/ui/hooks/supabase-provider', () => ({
   default: class {
     id: number;
     destroyed = false;
+    hydrated = false;
     awareness: { destroy: () => void };
     private listeners = new Map<string, (value: unknown) => void>();
     constructor(
@@ -31,6 +32,7 @@ vi.mock('@tuturuuu/ui/hooks/supabase-provider', () => ({
       this.listeners.set(event, callback);
     }
     emit(event: string, value: unknown) {
+      if (event === 'hydrated') this.hydrated = true;
       this.listeners.get(event)?.(value);
     }
     destroy() {
@@ -105,4 +107,41 @@ describe('collaboration hook lifecycle', () => {
     expect(second.destroyed).toBe(true);
     expect(vi.getTimerCount()).toBe(0);
   });
+  it('publishes durable hydration independently and fences an old document', async () => {
+    const { result, rerender, unmount } = renderHook(
+      (id) =>
+        useYjsCollaboration({ ...config, id, channel: `task-editor-${id}` }),
+      { wrapper, initialProps: 'one' }
+    );
+    const first = instances[0]!;
+    act(() => first.emit('hydrated', undefined));
+    expect(result.current.hydrated).toBe(true);
+    expect(result.current.connected).toBe(false);
+    rerender('two');
+    expect(result.current.hydrated).toBe(false);
+    act(() => first.emit('hydrated', undefined));
+    expect(result.current.hydrated).toBe(false);
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+  });
+  it('reports a durable read failure until a successful hydration', async () => {
+    const { result, unmount } = renderHook(() => useYjsCollaboration(config), {
+      wrapper,
+    });
+    const provider = instances[0]!;
+    act(() =>
+      provider.emit('error', {
+        message: 'Unable to load',
+        status: 'DOCUMENT_ERROR',
+        channel: config.channel,
+      })
+    );
+    expect(result.current.hydrationFailed).toBe(true);
+    expect(result.current.hydrated).toBe(false);
+    act(() => provider.emit('hydrated', undefined));
+    expect(result.current.hydrationFailed).toBe(false);
+    expect(result.current.hydrated).toBe(true);
+    unmount();
+    await act(() => vi.advanceTimersByTimeAsync(100));
+  });
 });

package/src/hooks/calendar-connection-types.ts

@@ -0,0 +1,49 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+// Type for calendar connection
+export type CalendarConnection = {
+  id: string;
+  ws_id: string;
+  calendar_id: string;
+  calendar_name: string;
+  is_enabled: boolean;
+  color: string | null;
+  provider?: 'google' | 'microsoft' | string;
+  auth_token_id?: string | null;
+  workspace_calendar_id?: string | null;
+  access_role?: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export type CalendarSyncStatus = {
+  state: 'idle' | 'syncing' | 'success' | 'error';
+  message?: string;
+  lastSyncTime?: Date;
+  direction?: 'google-to-tuturuuu' | 'tuturuuu-to-google' | 'both';
+};
+export type CalendarOptimisticStatus =
+  | 'creating'
+  | 'updating'
+  | 'deleting'
+  | 'error';
+
+export type OptimisticCalendarSyncEvent = Partial<
+  Omit<CalendarEvent, 'color' | 'description' | 'location'>
+> &
+  Pick<CalendarEvent, 'id'> & {
+    color?: CalendarEvent['color'] | string | null;
+    description?: string | null;
+    location?: string | null;
+    _optimisticStatus?: CalendarOptimisticStatus;
+  };
+
+export type OptimisticCalendarPatchOptions = {
+  removeIds?: string[];
+  clearIds?: string[];
+  status?: CalendarOptimisticStatus;
+};
+
+export type OptimisticCalendarState = {
+  events: Record<string, OptimisticCalendarSyncEvent>;
+  removedIds: string[];
+};

package/src/hooks/calendar-event-update-queue-types.ts

@@ -0,0 +1,12 @@
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+
+export interface PendingEventUpdate extends Partial<CalendarEvent> {
+  _updateId?: string;
+  _timestamp: number;
+  _eventId: string;
+  _previousEvent?: CalendarEvent;
+  _resolvers?: Array<{
+    resolve: (value: CalendarEvent) => void;
+    reject: (reason: unknown) => void;
+  }>;
+}