@tuturuuu/ui 0.37.0 → 0.37.2

package/src/hooks/use-calendar-sync.tsx

@@ -9,7 +9,6 @@ import type {
 } from '@tuturuuu/types';
 import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
 import { isAllDayEvent } from '@tuturuuu/utils/calendar-utils';
-import dayjs from 'dayjs';
 import {
   createContext,
   type SetStateAction,
@@ -21,12 +20,18 @@ import {
   useState,
 } from 'react';
 import { toast } from '../components/ui/sonner';
+import { calendarQueryRange } from '../lib/calendar-day';
 import { runCalendarProviderSync } from './calendar-provider-sync';
 import {
   type CacheUpdate,
   type CalendarCache,
   updateCalendarRangeCache,
 } from './calendar-range-cache';
+import {
+  calendarEventInQueryRange,
+  calendarRangeCacheKey,
+  calendarRangeIncludesToday,
+} from './calendar-sync-range';
 
 // Type for calendar connection
 type CalendarConnection = {
@@ -91,6 +96,8 @@ const CalendarSyncContext = createContext<{
   googleData: WorkspaceCalendarEvent[] | null;
   error: Error | null;
   dates: Date[];
+  timezone: string | undefined;
+  setTimezone: (timezone: string | undefined) => void;
 
   setDates: (dates: Date[]) => void;
   currentView: 'day' | '4-day' | 'week' | 'month';
@@ -141,6 +148,8 @@ const CalendarSyncContext = createContext<{
   googleData: null,
   error: null,
   dates: [],
+  timezone: undefined,
+  setTimezone: () => {},
   setDates: () => {},
   currentView: 'day',
   setCurrentView: () => {},
@@ -196,6 +205,7 @@ export const CalendarSyncProvider = ({
 
   const [error, setError] = useState<Error | null>(null);
   const [dates, setDates] = useState<Date[]>([]);
+  const [timezone, setTimezone] = useState<string>();
   const [currentView, setCurrentView] = useState<
     'day' | '4-day' | 'week' | 'month'
   >('day');
@@ -257,53 +267,18 @@ export const CalendarSyncProvider = ({
 
   const setCalendarConnections = setCalendarConnectionsState;
 
-  // Helper to generate cache key from dates
-  const getCacheKey = useCallback((dateRange: Date[]) => {
-    if (!dateRange || dateRange.length === 0) {
-      return '';
-    }
-    return `${dateRange[0]!.toISOString()}-${dateRange[dateRange.length - 1]!.toISOString()}`;
-  }, []);
-
   const activeCacheKey = useMemo(
-    () => (dates.length ? `${wsId}:${getCacheKey(dates)}` : ''),
-    [dates, getCacheKey, wsId]
+    () =>
+      dates.length ? `${wsId}:${calendarRangeCacheKey(dates, timezone)}` : '',
+    [dates, timezone, wsId]
   );
   const activeCachedDatabaseEvents = activeCacheKey
     ? calendarCache[activeCacheKey]?.dbEvents
     : undefined;
 
-  // Helper to check if a date range includes today (current week issue)
-  const includesCurrentWeek = useCallback((dateRange: Date[]) => {
-    if (!dateRange || dateRange.length === 0) return false;
-    const today = new Date();
-    const startOfToday = new Date(
-      today.getFullYear(),
-      today.getMonth(),
-      today.getDate()
-    );
-    const endOfToday = new Date(
-      today.getFullYear(),
-      today.getMonth(),
-      today.getDate(),
-      23,
-      59,
-      59
-    );
-
-    const firstDate = dateRange[0];
-    const lastDate = dateRange[dateRange.length - 1];
-    if (!firstDate || !lastDate) return false;
-
-    const rangeStart = new Date(firstDate);
-    const rangeEnd = new Date(lastDate);
-
-    return rangeStart <= endOfToday && rangeEnd >= startOfToday;
-  }, []);
-
   // Enhanced cache staleness check - shorter staleness for current week
   const isCacheStaleEnhanced = (lastUpdated: number, dateRange: Date[]) => {
-    const isCurrentWeek = includesCurrentWeek(dateRange);
+    const isCurrentWeek = calendarRangeIncludesToday(dateRange, timezone);
     // 30 seconds for current week, 5 minutes for other weeks
     const staleTime = isCurrentWeek ? 30 * 1000 : 5 * 60 * 1000; // 30 seconds
     return Date.now() - lastUpdated >= staleTime;
@@ -316,27 +291,9 @@ export const CalendarSyncProvider = ({
   }, []);
 
   const isVisibleInCurrentRange = useCallback(
-    (event: { start_at?: string; end_at?: string }) => {
-      if (dates.length === 0) return true;
-
-      const firstDate = dates[0];
-      const lastDate = dates[dates.length - 1];
-      if (!firstDate || !lastDate) return true;
-
-      if (!event.start_at && !event.end_at) return true;
-
-      const rangeStart = dayjs(firstDate).startOf('day').valueOf();
-      const rangeEnd = dayjs(lastDate).endOf('day').valueOf();
-      const startAt = event.start_at ? dayjs(event.start_at).valueOf() : NaN;
-      const endAt = event.end_at ? dayjs(event.end_at).valueOf() : startAt;
-
-      if (Number.isNaN(startAt) || Number.isNaN(endAt)) {
-        return true;
-      }
-
-      return startAt <= rangeEnd && endAt >= rangeStart;
-    },
-    [dates]
+    (event: { start_at?: string; end_at?: string }) =>
+      calendarEventInQueryRange(event, dates, timezone),
+    [dates, timezone]
   );
 
   const patchVisibleEvents = useCallback(
@@ -417,10 +374,10 @@ export const CalendarSyncProvider = ({
       }
 
       // Otherwise fetch fresh data via API (which handles E2EE decryption)
-      const startDate = dayjs(dates[0]).startOf('day');
-      const endDate = dayjs(dates[dates.length - 1])
-        .add(1, 'day')
-        .startOf('day');
+      const { start: startDate, end: endDate } = calendarQueryRange(
+        dates,
+        timezone
+      );
 
       try {
         const response = await fetch(
@@ -494,10 +451,10 @@ export const CalendarSyncProvider = ({
     staleTime: 2 * 60_000,
     gcTime: 30 * 60_000,
     queryFn: async () => {
-      const startDate = dayjs(dates[0]).startOf('day');
-      const endDate = dayjs(dates[dates.length - 1])
-        .add(1, 'day')
-        .startOf('day');
+      const { start: startDate, end: endDate } = calendarQueryRange(
+        dates,
+        timezone
+      );
 
       try {
         const response = await fetch(
@@ -534,15 +491,18 @@ export const CalendarSyncProvider = ({
   });
 
   // Helper to check if dates have actually changed
-  const areDatesEqual = useCallback((newDates: Date[]) => {
-    const newDatesStr = JSON.stringify(newDates.map((d) => d.toISOString()));
-    const prevDatesStr = prevDatesRef.current;
-    const areEqual = newDatesStr === prevDatesStr;
-    if (!areEqual) {
-      prevDatesRef.current = newDatesStr;
-    }
-    return areEqual;
-  }, []);
+  const areDatesEqual = useCallback(
+    (newDates: Date[]) => {
+      const newDatesStr = calendarRangeCacheKey(newDates, timezone);
+      const prevDatesStr = prevDatesRef.current;
+      const areEqual = newDatesStr === prevDatesStr;
+      if (!areEqual) {
+        prevDatesRef.current = newDatesStr;
+      }
+      return areEqual;
+    },
+    [timezone]
+  );
 
   // Invalidate and refetch events
   const refresh = useCallback(() => {
@@ -654,7 +614,7 @@ export const CalendarSyncProvider = ({
     const cacheData = calendarCache[activeCacheKey];
 
     // For current week, force a fresh database fetch
-    const isCurrentWeek = includesCurrentWeek(dates);
+    const isCurrentWeek = calendarRangeIncludesToday(dates, timezone);
 
     if (cacheData && isCurrentWeek) {
       isForcedRef.current = true;
@@ -666,7 +626,7 @@ export const CalendarSyncProvider = ({
   }, [
     dates,
     calendarCache,
-    includesCurrentWeek,
+    timezone,
     areDatesEqual,
     activeCacheKey,
     updateCache,
@@ -841,6 +801,8 @@ export const CalendarSyncProvider = ({
     error,
     dates,
     setDates,
+    timezone,
+    setTimezone,
     currentView,
     setCurrentView,
     syncToTuturuuu,

package/src/hooks/use-calendar.tsx

@@ -437,7 +437,7 @@ export const CalendarProvider = ({
   const updateQueueRef = useRef<PendingEventUpdate[]>([]);
   const isProcessingQueueRef = useRef<boolean>(false);
 
-  const { events, refresh, patchVisibleEvents } = useCalendarSync();
+  const { events, refresh, patchVisibleEvents, timezone } = useCalendarSync();
 
   const [activeEventId, setActiveEventId] = useState<string | null>(null);
   const [previewEventId, setPreviewEventId] = useState<string | null>(null);
@@ -503,8 +503,8 @@ export const CalendarProvider = ({
   );
 
   const getCurrentEvents = useMemo(
-    () => createCalendarEventLookup(events),
-    [events]
+    () => createCalendarEventLookup(events, timezone),
+    [events, timezone]
   );
 
   const getUpcomingEvent = useCallback(() => {

package/src/hooks/use-visible-workspaces.ts

@@ -0,0 +1,57 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { listWorkspaces } from '@tuturuuu/internal-api/workspaces';
+import {
+  useWorkspaceActor,
+  useWorkspaceVisibility,
+} from './use-workspace-visibility';
+
+/** UI choices only. Do not use this hook for access or membership reconciliation. */
+export function useVisibleWorkspaces(
+  enabled = true,
+  limit?: number,
+  options?: { refetchInterval?: number }
+) {
+  const actor = useWorkspaceActor();
+  const visibility = useWorkspaceVisibility(enabled);
+  const query = useQuery({
+    queryKey: [
+      'workspace-ui-list',
+      actor?.actorId,
+      ...(limit !== undefined ? [limit] : []),
+    ],
+    enabled: enabled && Boolean(actor),
+    refetchInterval: options?.refetchInterval,
+    queryFn: async () => {
+      actor!.assertActive();
+      const result = await listWorkspaces(
+        limit !== undefined ? { limit } : undefined
+      );
+      actor!.assertActive();
+      return result;
+    },
+  });
+  const data = visibility.known
+    ? query.data?.filter(
+        (workspace) => !visibility.hiddenIds.includes(workspace.id)
+      )
+    : undefined;
+  return {
+    ...query,
+    personalWorkspaceMissing:
+      visibility.known &&
+      query.data !== undefined &&
+      !query.data.some((workspace) => workspace.personal),
+    data,
+    isLoading:
+      enabled &&
+      (query.isLoading || (!visibility.known && !visibility.isError)),
+    isError: query.isError || visibility.isError,
+    error: query.error ?? visibility.error,
+    refetch: async () => {
+      const visibilityResult = await visibility.refetch();
+      return visibilityResult ? query.refetch() : null;
+    },
+  };
+}

package/src/hooks/use-workspace-user.ts

@@ -3,6 +3,7 @@
 import { useQuery } from '@tanstack/react-query';
 import { getCurrentUserProfile } from '@tuturuuu/internal-api/users';
 import type { WorkspaceUser } from '@tuturuuu/types/primitives/WorkspaceUser';
+import { useWorkspaceActor } from './use-workspace-visibility';
 
 /**
  * Hook to fetch the current workspace user with their private details
@@ -10,11 +11,18 @@ import type { WorkspaceUser } from '@tuturuuu/types/primitives/WorkspaceUser';
  *
  * @returns Query object with user data, loading state, and error info
  */
-export function useWorkspaceUser() {
-  return useQuery({
-    queryKey: ['workspace-user'],
+export function useWorkspaceUser(actorId?: string) {
+  const actor = useWorkspaceActor();
+  const resolvedActorId = actorId ?? actor?.actorId;
+  const query = useQuery({
+    queryKey: ['workspace-user', resolvedActorId],
+    enabled: Boolean(actor) && actor?.actorId === resolvedActorId,
     queryFn: async (): Promise<WorkspaceUser> => {
+      actor!.assertActive();
       const data = await getCurrentUserProfile();
+      actor!.assertActive();
+      if (data.id !== resolvedActorId)
+        throw new Error('Workspace account changed');
       return {
         id: data.id,
         email: data.email,
@@ -30,4 +38,8 @@ export function useWorkspaceUser() {
     gcTime: 10 * 60 * 1000, // Keep cached data for 10 minutes
     retry: 1, // Retry once on failure
   });
+  return {
+    ...query,
+    data: actor?.actorId === resolvedActorId ? query.data : undefined,
+  };
 }

package/src/hooks/use-workspace-visibility.ts

@@ -0,0 +1,234 @@
+'use client';
+
+import {
+  type QueryClient,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
+import { InternalApiError } from '@tuturuuu/internal-api/client';
+import {
+  getCurrentUserHiddenWorkspaces,
+  updateCurrentUserHiddenWorkspace,
+} from '@tuturuuu/internal-api/users';
+import {
+  createContext,
+  createElement,
+  type ReactNode,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+const controls = new WeakMap<
+  QueryClient,
+  Map<string, { revision: number; pending: Set<string> }>
+>();
+function ownerControl(client: QueryClient, actorId: string) {
+  let actors = controls.get(client);
+  if (!actors) {
+    actors = new Map();
+    controls.set(client, actors);
+  }
+  let control = actors.get(actorId);
+  if (!control) {
+    control = { revision: 0, pending: new Set() };
+    actors.set(actorId, control);
+  }
+  return control;
+}
+
+type ActorScope = {
+  actorId: string;
+  lifetime: { active: boolean };
+  assertActive: () => void;
+};
+const ActorContext = createContext<ActorScope | null>(null);
+
+/** Feed only a server-verified actor; preferences never become membership data. */
+export function WorkspaceVisibilityProvider({
+  actorId,
+  children,
+}: {
+  actorId: string;
+  children: ReactNode;
+}) {
+  const parent = useContext(ActorContext);
+  const current = useRef(actorId);
+  current.current = actorId;
+  const scope = useMemo(() => {
+    if (parent?.actorId === actorId) return parent;
+    const lifetime = { active: true };
+    return {
+      actorId,
+      lifetime,
+      assertActive() {
+        parent?.assertActive();
+        if (
+          !lifetime.active ||
+          current.current !== actorId ||
+          (parent && parent.actorId !== actorId)
+        ) {
+          throw new Error('Workspace account changed');
+        }
+      },
+    };
+  }, [actorId, parent]);
+  const client = useQueryClient();
+  useEffect(() => {
+    if (scope === parent) return;
+    scope.lifetime.active = true;
+    return () => {
+      scope.lifetime.active = false;
+      controls.get(client)?.delete(scope.actorId);
+      // A private cache is never retained across logout/account replacement.
+      client.removeQueries({ queryKey: ['workspace-hidden', scope.actorId] });
+      client.removeQueries({ queryKey: ['workspace-ui-list', scope.actorId] });
+      client.removeQueries({ queryKey: ['user-workspaces', scope.actorId] });
+      client.removeQueries({ queryKey: ['all-user-boards', scope.actorId] });
+      client.removeQueries({ queryKey: ['chat-workspaces', scope.actorId] });
+      client.removeQueries({ queryKey: ['task-source-boards', scope.actorId] });
+      client.removeQueries({ queryKey: ['workspace-user', scope.actorId] });
+      client.removeQueries({
+        queryKey: ['workspace-invitations', scope.actorId],
+      });
+      client.removeQueries({
+        predicate: (query) =>
+          query.queryKey[0] === 'global-command-launcher' &&
+          query.queryKey.includes(scope.actorId),
+      });
+      client.removeQueries({
+        queryKey: ['workspace-select-current-workspace', scope.actorId],
+      });
+    };
+  }, [scope, parent, client]);
+  return createElement(
+    ActorContext.Provider,
+    {
+      key: actorId,
+      value: parent && parent.actorId !== actorId ? null : scope,
+    },
+    children
+  );
+}
+
+export function useWorkspaceActor() {
+  return useContext(ActorContext);
+}
+
+export function useWorkspaceVisibility(enabled = true) {
+  const scope = useWorkspaceActor();
+  const actorId = scope?.actorId;
+  const client = useQueryClient();
+  const key = ['workspace-hidden', actorId] as const;
+  const control = ownerControl(client, actorId ?? 'signed-out');
+  const [pending, setPending] = useState<Set<string>>(new Set());
+  const [updateError, setUpdateError] = useState<Error | null>(null);
+  const query = useQuery({
+    queryKey: key,
+    enabled: enabled && Boolean(scope),
+    queryFn: async () => {
+      scope!.assertActive();
+      if (control.pending.size > 0) {
+        const optimistic = client.getQueryData<string[]>(key);
+        if (optimistic) return optimistic;
+      }
+      const requestRevision = control.revision;
+      const response = await getCurrentUserHiddenWorkspaces(actorId!);
+      scope!.assertActive();
+      // A refresh started before a mutation cannot overwrite its optimistic state.
+      if (requestRevision !== control.revision) {
+        return (
+          client.getQueryData<string[]>(key) ?? response.hiddenWorkspaceIds
+        );
+      }
+      return response.hiddenWorkspaceIds;
+    },
+    staleTime: 30_000,
+    retry: 1,
+  });
+  const accountDenied =
+    query.error instanceof InternalApiError &&
+    [401, 403, 409].includes(query.error.status);
+  const ids = accountDenied ? undefined : query.data;
+  async function setHidden(workspaceId: string, hidden: boolean) {
+    if (!scope || !ids || control.pending.has(workspaceId)) return;
+    scope.assertActive();
+    const ownerKey = ['workspace-hidden', scope.actorId] as const;
+    const wasHidden = ids.includes(workspaceId);
+    control.pending.add(workspaceId);
+    setPending(new Set(control.pending));
+    setUpdateError(null);
+    control.revision++;
+    await client.cancelQueries({ queryKey: ownerKey });
+    scope.assertActive();
+    client.setQueryData<string[]>(ownerKey, (current = []) =>
+      hidden
+        ? [...new Set([...current, workspaceId])]
+        : current.filter((id) => id !== workspaceId)
+    );
+    try {
+      await updateCurrentUserHiddenWorkspace(
+        workspaceId,
+        hidden,
+        scope.actorId
+      );
+      scope.assertActive();
+    } catch (error) {
+      try {
+        scope.assertActive();
+      } catch {
+        return;
+      }
+      client.setQueryData<string[]>(ownerKey, (current = []) =>
+        wasHidden
+          ? [...new Set([...current, workspaceId])]
+          : current.filter((id) => id !== workspaceId)
+      );
+      setUpdateError(
+        error instanceof Error
+          ? error
+          : new Error('Unable to update Hidden workspaces')
+      );
+      throw error;
+    } finally {
+      control.pending.delete(workspaceId);
+      try {
+        scope.assertActive();
+        setPending(new Set(control.pending));
+        if (control.pending.size === 0) {
+          void client.invalidateQueries({ queryKey: ownerKey });
+        }
+      } catch {
+        /* An old account cannot publish into the next account. */
+      }
+    }
+  }
+  return {
+    ...query,
+    refetch: async () => {
+      if (!scope) return null;
+      try {
+        scope.assertActive();
+      } catch {
+        return null;
+      }
+      const result = await query.refetch();
+      try {
+        scope.assertActive();
+      } catch {
+        return null;
+      }
+      if (!result.error) setUpdateError(null);
+      return result;
+    },
+    accountDenied,
+    actorId,
+    hiddenIds: ids ?? [],
+    known: ids !== undefined,
+    pending,
+    updateError,
+    setHidden,
+  };
+}

package/src/lib/calendar-day.ts

@@ -0,0 +1,67 @@
+import {
+  buildDateInTimezone,
+  getDatePartsInTimezone,
+  resolveTaskTimezone,
+} from '@tuturuuu/utils/task-date-timezone';
+
+/** Local fields carry a calendar day; this Date is never an event instant. */
+export function calendarDay(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+export function calendarDayKey(date: Date): string {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+}
+export function calendarInstantDay(instant: Date, zone?: string): Date {
+  const parts = getDatePartsInTimezone(
+    instant,
+    resolveTaskTimezone(zone ?? 'auto')
+  );
+  return new Date(parts.year, parts.month - 1, parts.day);
+}
+export function calendarToday(zone?: string, now = new Date()): Date {
+  return calendarInstantDay(now, zone);
+}
+/** Construct each midnight independently so DST days can span 23 or 25 hours. */
+export function calendarDayBoundary(day: Date, zone?: string): Date {
+  return buildDateInTimezone(
+    day.getFullYear(),
+    day.getMonth() + 1,
+    day.getDate(),
+    0,
+    0,
+    resolveTaskTimezone(zone ?? 'auto')
+  );
+}
+export function calendarQueryRange(dates: Date[], zone?: string) {
+  const first = dates[0];
+  const last = dates.at(-1);
+  if (!first || !last) throw new Error('Calendar range needs at least one day');
+  const afterLast = new Date(
+    last.getFullYear(),
+    last.getMonth(),
+    last.getDate() + 1
+  );
+  return {
+    start: calendarDayBoundary(first, zone),
+    end: calendarDayBoundary(afterLast, zone),
+  };
+}
+/** Date-only navigation preserves its YMD; timestamp navigation projects an instant. */
+export function calendarNavigationDate(
+  value: string,
+  zone?: string
+): Date | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (match) {
+    const date = new Date(
+      Number(match[1]),
+      Number(match[2]) - 1,
+      Number(match[3])
+    );
+    return calendarDayKey(date) === value ? date : null;
+  }
+  const instant = new Date(value);
+  return Number.isFinite(instant.getTime())
+    ? calendarInstantDay(instant, zone)
+    : null;
+}