@tuturuuu/ui 0.38.0 → 0.39.1

package/src/hooks/use-calendar.tsx

@@ -26,6 +26,7 @@ import {
   useRef,
   useState,
 } from 'react';
+import { NativeRecurrenceContextMenu } from '../components/ui/legacy/calendar/native-recurrence-context-menu';
 import { getTaskApiUrl } from '../lib/tasks-app-url';
 import {
   createCalendarCreationRequests,
@@ -33,7 +34,13 @@ import {
 } from './calendar-creation-request';
 import { roundToNearest15Minutes } from './calendar-date-utils';
 import { createCalendarEventLookup } from './calendar-event-lookup';
-import { calendarEventUpdatePayload } from './calendar-event-write-payload';
+import type { PendingEventUpdate } from './calendar-event-update-queue-types';
+import {
+  assertOrdinaryCalendarEvent,
+  calendarEventByIdentity,
+  calendarEventUpdatePayload,
+  cleanCalendarEventUpdates,
+} from './calendar-event-write-payload';
 import { useCalendarSync } from './use-calendar-sync';
 import { useOpenInitialCalendarEvent } from './use-open-initial-calendar-event';
 
@@ -229,18 +236,6 @@ const CalendarContext = createContext<{
   readOnly: false,
 });
 
-// Add this interface before the updateEvent function
-interface PendingEventUpdate extends Partial<CalendarEvent> {
-  _updateId?: string;
-  _timestamp: number;
-  _eventId: string;
-  _previousEvent?: CalendarEvent;
-  _resolvers?: Array<{
-    resolve: (value: CalendarEvent) => void;
-    reject: (reason: unknown) => void;
-  }>;
-}
-
 export type CalendarEventAdapter = {
   disableBuiltInEventUi?: boolean;
   preservePastEventOpacity?: boolean;
@@ -484,11 +479,7 @@ export const CalendarProvider = ({
   // Event getters
   const getEvent = useCallback(
     (eventId: string) => {
-      // Handle IDs for split multi-day events (they contain a dash and date)
-      const originalId = eventId.includes('-')
-        ? eventId.split('-')[0]
-        : eventId;
-      return events.find((e: Partial<CalendarEvent>) => e.id === originalId);
+      return calendarEventByIdentity(events, eventId);
     },
     [events]
   );
@@ -917,24 +908,8 @@ export const CalendarProvider = ({
         return undefined;
       }
 
-      // Clean and validate the event updates - only allow known CalendarEvent fields
-      const allowedFields: (keyof CalendarEvent)[] = [
-        'title',
-        'description',
-        'start_at',
-        'end_at',
-        'color',
-        'location',
-        'locked',
-        'source',
-      ];
-
-      const cleanedUpdates: Partial<CalendarEvent> = {};
-      for (const field of allowedFields) {
-        if (eventUpdates[field] !== undefined) {
-          (cleanedUpdates as any)[field] = eventUpdates[field];
-        }
-      }
+      assertOrdinaryCalendarEvent(events, eventId);
+      const cleanedUpdates = cleanCalendarEventUpdates(eventUpdates);
 
       // Round start and end times to nearest 15-minute interval if they exist
       if (cleanedUpdates.start_at) {
@@ -1075,6 +1050,7 @@ export const CalendarProvider = ({
         console.warn('Calendar is in read-only mode');
         return;
       }
+      assertOrdinaryCalendarEvent(events, eventId);
       // If this is a pending new event that hasn't been saved yet
       if (pendingNewEvent && eventId === 'new') {
         // Just clear the pending event
@@ -1618,8 +1594,18 @@ export const CalendarProvider = ({
     defaultNewEventTab,
     disableBuiltInEventUi: eventAdapter?.disableBuiltInEventUi ?? false,
     preservePastEventOpacity: eventAdapter?.preservePastEventOpacity ?? false,
-    renderEventContextMenu: eventAdapter?.renderContextMenu,
-    isEventReadOnly: eventAdapter?.isEventReadOnly ?? (() => false),
+    renderEventContextMenu: (event: CalendarEvent) =>
+      event.seriesId ? (
+        <NativeRecurrenceContextMenu
+          onEdit={() => openEventEditor(event._originalId ?? event.id)}
+          readOnly={readOnly}
+        />
+      ) : (
+        eventAdapter?.renderContextMenu?.(event)
+      ),
+    isEventReadOnly: (event: CalendarEvent) =>
+      Boolean(event.seriesId) ||
+      (eventAdapter?.isEventReadOnly?.(event) ?? false),
     readOnly,
   };
 

package/src/hooks/use-local-storage.ts

@@ -9,16 +9,14 @@ export const useLocalStorage = <T>(
   const [initialized, setInitialized] = useState(false);
 
   useEffect(() => {
-    // Retrieve from localStorage
-    const item = window.localStorage.getItem(key);
-    if (item) {
-      try {
-        setStoredValue(JSON.parse(item));
-      } catch (error) {
-        console.error(error);
-      }
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item) setStoredValue(JSON.parse(item));
+    } catch {
+      console.error('Unable to read browser preferences.');
+    } finally {
+      setInitialized(true);
     }
-    setInitialized(true);
   }, [key]);
 
   const setValue = useCallback(
@@ -29,8 +27,8 @@ export const useLocalStorage = <T>(
         // Save to localStorage
         try {
           window.localStorage.setItem(key, JSON.stringify(valueToStore));
-        } catch (error) {
-          console.error(error);
+        } catch {
+          console.error('Unable to save browser preferences.');
         }
         return valueToStore;
       });

package/src/hooks/use-native-calendar-occurrences.ts

@@ -0,0 +1,85 @@
+'use client';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { listNativeCalendarOccurrences } from '@tuturuuu/internal-api/calendar-series';
+import { InternalApiError } from '@tuturuuu/internal-api/client';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
+import { useEffect } from 'react';
+import { calendarQueryRange } from '../lib/calendar-day';
+import { useWorkspaceActor } from './use-workspace-visibility';
+export const EMPTY_NATIVE_OCCURRENCES: CalendarEvent[] = [];
+export const nativeOccurrencesKey = (wsId: string) =>
+  ['native-calendar-occurrences', wsId] as const;
+export function deniedNativeOccurrences(error: unknown) {
+  return (
+    error instanceof InternalApiError &&
+    (error.status === 401 ||
+      error.status === 404 ||
+      (error.status === 403 && error.code !== 'MFA_REQUIRED'))
+  );
+}
+/** A denied snapshot is never rendered as stale data. MFA is a recoverable challenge. */
+export function visibleNativeOccurrences(
+  data: CalendarEvent[] | undefined,
+  error: unknown
+) {
+  return deniedNativeOccurrences(error)
+    ? EMPTY_NATIVE_OCCURRENCES
+    : (data ?? EMPTY_NATIVE_OCCURRENCES);
+}
+export function useNativeCalendarOccurrences(
+  wsId: string,
+  dates: Date[],
+  timezone: string | undefined,
+  external: boolean
+) {
+  const actor = useWorkspaceActor();
+  const actorId = actor?.actorId;
+  const client = useQueryClient();
+  const range = dates.length ? calendarQueryRange(dates, timezone) : undefined;
+  const from = range?.start.toISOString();
+  const to = range?.end.toISOString();
+  const key = [...nativeOccurrencesKey(wsId), actorId, from, to];
+  const enabled = !external && !!actor && !!wsId && !!from && !!to;
+  useEffect(
+    () => () => {
+      client.removeQueries({
+        queryKey: [...nativeOccurrencesKey(wsId), actorId],
+      });
+    },
+    [client, wsId, actorId]
+  );
+  const query = useQuery({
+    queryKey: key,
+    enabled,
+    queryFn: async ({ signal }) => {
+      actor!.assertActive();
+      try {
+        const result = await listNativeCalendarOccurrences(
+          wsId,
+          { from: from!, to: to! },
+          { signal }
+        );
+        actor!.assertActive();
+        return result.data;
+      } catch (error) {
+        if (deniedNativeOccurrences(error))
+          client.setQueryData(key, EMPTY_NATIVE_OCCURRENCES);
+        throw error;
+      }
+    },
+    staleTime: 30_000,
+    gcTime: 30 * 60_000,
+    retry: (count, error) =>
+      !(
+        error instanceof InternalApiError &&
+        error.status >= 400 &&
+        error.status < 500
+      ) && count < 2,
+  });
+  return {
+    ...query,
+    data: enabled
+      ? visibleNativeOccurrences(query.data, query.error)
+      : EMPTY_NATIVE_OCCURRENCES,
+  };
+}

package/src/hooks/use-yjs-collaboration.ts

@@ -33,6 +33,8 @@ export interface YjsCollaborationResult {
   awareness: Awareness | null;
   provider: SupabaseProvider | null;
   synced: boolean;
+  hydrated: boolean;
+  hydrationFailed: boolean;
   connected: boolean;
 }
 
@@ -62,6 +64,10 @@ export function useYjsCollaboration(
     onSave,
   } = config;
 
+  const [hydratedProvider, setHydratedProvider] =
+    useState<SupabaseProvider | null>(null);
+  const [hydrationErrorProvider, setHydrationErrorProvider] =
+    useState<SupabaseProvider | null>(null);
   const [synced, setSynced] = useState(false);
   const [connected, setConnected] = useState(false);
   const [providerState, setProviderState] = useState<SupabaseProvider | null>(
@@ -176,6 +182,15 @@ export function useYjsCollaboration(
 
     providerRef.current = provider;
     setProviderState(provider);
+    setSynced(false);
+    setConnected(false);
+
+    provider.on('hydrated', () => {
+      if (!mountedRef.current || providerRef.current !== provider) return;
+      // Publish a new state value so hydration is observable without transport.
+      setHydratedProvider(provider);
+      setHydrationErrorProvider(null);
+    });
 
     // Listen to provider events — use mountedRef so listeners stay valid
     // across StrictMode cleanup/remount without re-registration.
@@ -217,6 +232,8 @@ export function useYjsCollaboration(
           channel: errorInfo.channel,
           status: errorInfo.status,
         });
+        if (errorInfo.status === 'DOCUMENT_ERROR')
+          setHydrationErrorProvider(provider);
         onErrorRef.current?.(new Error(errorInfo.message));
       }
     );
@@ -308,6 +325,12 @@ export function useYjsCollaboration(
       providerState && providerState.id === doc?.clientID
         ? providerState
         : null,
+    hydrated:
+      !!hydratedProvider &&
+      hydratedProvider.id === doc?.clientID &&
+      hydratedProvider.hydrated,
+    hydrationFailed:
+      !!hydrationErrorProvider && hydrationErrorProvider.id === doc?.clientID,
     synced: !!providerState && providerState.id === doc?.clientID && synced,
     connected:
       !!providerState && providerState.id === doc?.clientID && connected,